strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    '''
   23
   24    '''
   25    __slots__ = [
   26        'bind_interface',
   27        'certificate_authority',
   28        'client_certificate',
   29        'client_key',
   30        'egress_filter',
   31        'healthcheck_namespace',
   32        'healthy',
   33        'hostname',
   34        'id',
   35        'name',
   36        'port',
   37        'port_override',
   38        'remote_identity_group_id',
   39        'remote_identity_healthcheck_username',
   40        'secret_store_id',
   41        'tags',
   42    ]
   43
   44    def __init__(
   45        self,
   46        bind_interface=None,
   47        certificate_authority=None,
   48        client_certificate=None,
   49        client_key=None,
   50        egress_filter=None,
   51        healthcheck_namespace=None,
   52        healthy=None,
   53        hostname=None,
   54        id=None,
   55        name=None,
   56        port=None,
   57        port_override=None,
   58        remote_identity_group_id=None,
   59        remote_identity_healthcheck_username=None,
   60        secret_store_id=None,
   61        tags=None,
   62    ):
   63        self.bind_interface = bind_interface if bind_interface is not None else ''
   64        '''
   65         Bind interface
   66        '''
   67        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   68        '''
   69
   70        '''
   71        self.client_certificate = client_certificate if client_certificate is not None else ''
   72        '''
   73
   74        '''
   75        self.client_key = client_key if client_key is not None else ''
   76        '''
   77
   78        '''
   79        self.egress_filter = egress_filter if egress_filter is not None else ''
   80        '''
   81         A filter applied to the routing logic to pin datasource to nodes.
   82        '''
   83        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   84        '''
   85         The path used to check the health of your connection.  Defaults to `default`.
   86        '''
   87        self.healthy = healthy if healthy is not None else False
   88        '''
   89         True if the datasource is reachable and the credentials are valid.
   90        '''
   91        self.hostname = hostname if hostname is not None else ''
   92        '''
   93
   94        '''
   95        self.id = id if id is not None else ''
   96        '''
   97         Unique identifier of the Resource.
   98        '''
   99        self.name = name if name is not None else ''
  100        '''
  101         Unique human-readable name of the Resource.
  102        '''
  103        self.port = port if port is not None else 0
  104        '''
  105
  106        '''
  107        self.port_override = port_override if port_override is not None else 0
  108        '''
  109
  110        '''
  111        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  112        '''
  113
  114        '''
  115        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  116        '''
  117
  118        '''
  119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  120        '''
  121         ID of the secret store containing credentials for this resource, if any.
  122        '''
  123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  124        '''
  125         Tags is a map of key, value pairs.
  126        '''
  127
  128    def __repr__(self):
  129        return '<sdm.AKS ' + \
  130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  131            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  132            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  133            'client_key: ' + repr(self.client_key) + ' ' +\
  134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  135            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  136            'healthy: ' + repr(self.healthy) + ' ' +\
  137            'hostname: ' + repr(self.hostname) + ' ' +\
  138            'id: ' + repr(self.id) + ' ' +\
  139            'name: ' + repr(self.name) + ' ' +\
  140            'port: ' + repr(self.port) + ' ' +\
  141            'port_override: ' + repr(self.port_override) + ' ' +\
  142            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  143            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  145            'tags: ' + repr(self.tags) + ' ' +\
  146            '>'
  147
  148    def to_dict(self):
  149        return {
  150            'bind_interface': self.bind_interface,
  151            'certificate_authority': self.certificate_authority,
  152            'client_certificate': self.client_certificate,
  153            'client_key': self.client_key,
  154            'egress_filter': self.egress_filter,
  155            'healthcheck_namespace': self.healthcheck_namespace,
  156            'healthy': self.healthy,
  157            'hostname': self.hostname,
  158            'id': self.id,
  159            'name': self.name,
  160            'port': self.port,
  161            'port_override': self.port_override,
  162            'remote_identity_group_id': self.remote_identity_group_id,
  163            'remote_identity_healthcheck_username':
  164            self.remote_identity_healthcheck_username,
  165            'secret_store_id': self.secret_store_id,
  166            'tags': self.tags,
  167        }
  168
  169    @classmethod
  170    def from_dict(cls, d):
  171        return cls(
  172            bind_interface=d.get('bind_interface'),
  173            certificate_authority=d.get('certificate_authority'),
  174            client_certificate=d.get('client_certificate'),
  175            client_key=d.get('client_key'),
  176            egress_filter=d.get('egress_filter'),
  177            healthcheck_namespace=d.get('healthcheck_namespace'),
  178            healthy=d.get('healthy'),
  179            hostname=d.get('hostname'),
  180            id=d.get('id'),
  181            name=d.get('name'),
  182            port=d.get('port'),
  183            port_override=d.get('port_override'),
  184            remote_identity_group_id=d.get('remote_identity_group_id'),
  185            remote_identity_healthcheck_username=d.get(
  186                'remote_identity_healthcheck_username'),
  187            secret_store_id=d.get('secret_store_id'),
  188            tags=d.get('tags'),
  189        )
  190
  191
  192class AKSBasicAuth:
  193    '''
  194
  195    '''
  196    __slots__ = [
  197        'bind_interface',
  198        'egress_filter',
  199        'healthcheck_namespace',
  200        'healthy',
  201        'hostname',
  202        'id',
  203        'name',
  204        'password',
  205        'port',
  206        'port_override',
  207        'secret_store_id',
  208        'tags',
  209        'username',
  210    ]
  211
  212    def __init__(
  213        self,
  214        bind_interface=None,
  215        egress_filter=None,
  216        healthcheck_namespace=None,
  217        healthy=None,
  218        hostname=None,
  219        id=None,
  220        name=None,
  221        password=None,
  222        port=None,
  223        port_override=None,
  224        secret_store_id=None,
  225        tags=None,
  226        username=None,
  227    ):
  228        self.bind_interface = bind_interface if bind_interface is not None else ''
  229        '''
  230         Bind interface
  231        '''
  232        self.egress_filter = egress_filter if egress_filter is not None else ''
  233        '''
  234         A filter applied to the routing logic to pin datasource to nodes.
  235        '''
  236        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  237        '''
  238         The path used to check the health of your connection.  Defaults to `default`.
  239        '''
  240        self.healthy = healthy if healthy is not None else False
  241        '''
  242         True if the datasource is reachable and the credentials are valid.
  243        '''
  244        self.hostname = hostname if hostname is not None else ''
  245        '''
  246
  247        '''
  248        self.id = id if id is not None else ''
  249        '''
  250         Unique identifier of the Resource.
  251        '''
  252        self.name = name if name is not None else ''
  253        '''
  254         Unique human-readable name of the Resource.
  255        '''
  256        self.password = password if password is not None else ''
  257        '''
  258
  259        '''
  260        self.port = port if port is not None else 0
  261        '''
  262
  263        '''
  264        self.port_override = port_override if port_override is not None else 0
  265        '''
  266
  267        '''
  268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  269        '''
  270         ID of the secret store containing credentials for this resource, if any.
  271        '''
  272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  273        '''
  274         Tags is a map of key, value pairs.
  275        '''
  276        self.username = username if username is not None else ''
  277        '''
  278
  279        '''
  280
  281    def __repr__(self):
  282        return '<sdm.AKSBasicAuth ' + \
  283            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  284            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  285            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  286            'healthy: ' + repr(self.healthy) + ' ' +\
  287            'hostname: ' + repr(self.hostname) + ' ' +\
  288            'id: ' + repr(self.id) + ' ' +\
  289            'name: ' + repr(self.name) + ' ' +\
  290            'password: ' + repr(self.password) + ' ' +\
  291            'port: ' + repr(self.port) + ' ' +\
  292            'port_override: ' + repr(self.port_override) + ' ' +\
  293            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  294            'tags: ' + repr(self.tags) + ' ' +\
  295            'username: ' + repr(self.username) + ' ' +\
  296            '>'
  297
  298    def to_dict(self):
  299        return {
  300            'bind_interface': self.bind_interface,
  301            'egress_filter': self.egress_filter,
  302            'healthcheck_namespace': self.healthcheck_namespace,
  303            'healthy': self.healthy,
  304            'hostname': self.hostname,
  305            'id': self.id,
  306            'name': self.name,
  307            'password': self.password,
  308            'port': self.port,
  309            'port_override': self.port_override,
  310            'secret_store_id': self.secret_store_id,
  311            'tags': self.tags,
  312            'username': self.username,
  313        }
  314
  315    @classmethod
  316    def from_dict(cls, d):
  317        return cls(
  318            bind_interface=d.get('bind_interface'),
  319            egress_filter=d.get('egress_filter'),
  320            healthcheck_namespace=d.get('healthcheck_namespace'),
  321            healthy=d.get('healthy'),
  322            hostname=d.get('hostname'),
  323            id=d.get('id'),
  324            name=d.get('name'),
  325            password=d.get('password'),
  326            port=d.get('port'),
  327            port_override=d.get('port_override'),
  328            secret_store_id=d.get('secret_store_id'),
  329            tags=d.get('tags'),
  330            username=d.get('username'),
  331        )
  332
  333
  334class AKSServiceAccount:
  335    '''
  336
  337    '''
  338    __slots__ = [
  339        'bind_interface',
  340        'egress_filter',
  341        'healthcheck_namespace',
  342        'healthy',
  343        'hostname',
  344        'id',
  345        'name',
  346        'port',
  347        'port_override',
  348        'remote_identity_group_id',
  349        'remote_identity_healthcheck_username',
  350        'secret_store_id',
  351        'tags',
  352        'token',
  353    ]
  354
  355    def __init__(
  356        self,
  357        bind_interface=None,
  358        egress_filter=None,
  359        healthcheck_namespace=None,
  360        healthy=None,
  361        hostname=None,
  362        id=None,
  363        name=None,
  364        port=None,
  365        port_override=None,
  366        remote_identity_group_id=None,
  367        remote_identity_healthcheck_username=None,
  368        secret_store_id=None,
  369        tags=None,
  370        token=None,
  371    ):
  372        self.bind_interface = bind_interface if bind_interface is not None else ''
  373        '''
  374         Bind interface
  375        '''
  376        self.egress_filter = egress_filter if egress_filter is not None else ''
  377        '''
  378         A filter applied to the routing logic to pin datasource to nodes.
  379        '''
  380        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  381        '''
  382         The path used to check the health of your connection.  Defaults to `default`.
  383        '''
  384        self.healthy = healthy if healthy is not None else False
  385        '''
  386         True if the datasource is reachable and the credentials are valid.
  387        '''
  388        self.hostname = hostname if hostname is not None else ''
  389        '''
  390
  391        '''
  392        self.id = id if id is not None else ''
  393        '''
  394         Unique identifier of the Resource.
  395        '''
  396        self.name = name if name is not None else ''
  397        '''
  398         Unique human-readable name of the Resource.
  399        '''
  400        self.port = port if port is not None else 0
  401        '''
  402
  403        '''
  404        self.port_override = port_override if port_override is not None else 0
  405        '''
  406
  407        '''
  408        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  409        '''
  410
  411        '''
  412        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  413        '''
  414
  415        '''
  416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  417        '''
  418         ID of the secret store containing credentials for this resource, if any.
  419        '''
  420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  421        '''
  422         Tags is a map of key, value pairs.
  423        '''
  424        self.token = token if token is not None else ''
  425        '''
  426
  427        '''
  428
  429    def __repr__(self):
  430        return '<sdm.AKSServiceAccount ' + \
  431            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  432            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  433            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  434            'healthy: ' + repr(self.healthy) + ' ' +\
  435            'hostname: ' + repr(self.hostname) + ' ' +\
  436            'id: ' + repr(self.id) + ' ' +\
  437            'name: ' + repr(self.name) + ' ' +\
  438            'port: ' + repr(self.port) + ' ' +\
  439            'port_override: ' + repr(self.port_override) + ' ' +\
  440            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  441            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  442            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  443            'tags: ' + repr(self.tags) + ' ' +\
  444            'token: ' + repr(self.token) + ' ' +\
  445            '>'
  446
  447    def to_dict(self):
  448        return {
  449            'bind_interface': self.bind_interface,
  450            'egress_filter': self.egress_filter,
  451            'healthcheck_namespace': self.healthcheck_namespace,
  452            'healthy': self.healthy,
  453            'hostname': self.hostname,
  454            'id': self.id,
  455            'name': self.name,
  456            'port': self.port,
  457            'port_override': self.port_override,
  458            'remote_identity_group_id': self.remote_identity_group_id,
  459            'remote_identity_healthcheck_username':
  460            self.remote_identity_healthcheck_username,
  461            'secret_store_id': self.secret_store_id,
  462            'tags': self.tags,
  463            'token': self.token,
  464        }
  465
  466    @classmethod
  467    def from_dict(cls, d):
  468        return cls(
  469            bind_interface=d.get('bind_interface'),
  470            egress_filter=d.get('egress_filter'),
  471            healthcheck_namespace=d.get('healthcheck_namespace'),
  472            healthy=d.get('healthy'),
  473            hostname=d.get('hostname'),
  474            id=d.get('id'),
  475            name=d.get('name'),
  476            port=d.get('port'),
  477            port_override=d.get('port_override'),
  478            remote_identity_group_id=d.get('remote_identity_group_id'),
  479            remote_identity_healthcheck_username=d.get(
  480                'remote_identity_healthcheck_username'),
  481            secret_store_id=d.get('secret_store_id'),
  482            tags=d.get('tags'),
  483            token=d.get('token'),
  484        )
  485
  486
  487class AKSServiceAccountUserImpersonation:
  488    '''
  489
  490    '''
  491    __slots__ = [
  492        'bind_interface',
  493        'egress_filter',
  494        'healthcheck_namespace',
  495        'healthy',
  496        'hostname',
  497        'id',
  498        'name',
  499        'port',
  500        'port_override',
  501        'secret_store_id',
  502        'tags',
  503        'token',
  504    ]
  505
  506    def __init__(
  507        self,
  508        bind_interface=None,
  509        egress_filter=None,
  510        healthcheck_namespace=None,
  511        healthy=None,
  512        hostname=None,
  513        id=None,
  514        name=None,
  515        port=None,
  516        port_override=None,
  517        secret_store_id=None,
  518        tags=None,
  519        token=None,
  520    ):
  521        self.bind_interface = bind_interface if bind_interface is not None else ''
  522        '''
  523         Bind interface
  524        '''
  525        self.egress_filter = egress_filter if egress_filter is not None else ''
  526        '''
  527         A filter applied to the routing logic to pin datasource to nodes.
  528        '''
  529        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  530        '''
  531         The path used to check the health of your connection.  Defaults to `default`.
  532        '''
  533        self.healthy = healthy if healthy is not None else False
  534        '''
  535         True if the datasource is reachable and the credentials are valid.
  536        '''
  537        self.hostname = hostname if hostname is not None else ''
  538        '''
  539
  540        '''
  541        self.id = id if id is not None else ''
  542        '''
  543         Unique identifier of the Resource.
  544        '''
  545        self.name = name if name is not None else ''
  546        '''
  547         Unique human-readable name of the Resource.
  548        '''
  549        self.port = port if port is not None else 0
  550        '''
  551
  552        '''
  553        self.port_override = port_override if port_override is not None else 0
  554        '''
  555
  556        '''
  557        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  558        '''
  559         ID of the secret store containing credentials for this resource, if any.
  560        '''
  561        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  562        '''
  563         Tags is a map of key, value pairs.
  564        '''
  565        self.token = token if token is not None else ''
  566        '''
  567
  568        '''
  569
  570    def __repr__(self):
  571        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  573            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  574            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  575            'healthy: ' + repr(self.healthy) + ' ' +\
  576            'hostname: ' + repr(self.hostname) + ' ' +\
  577            'id: ' + repr(self.id) + ' ' +\
  578            'name: ' + repr(self.name) + ' ' +\
  579            'port: ' + repr(self.port) + ' ' +\
  580            'port_override: ' + repr(self.port_override) + ' ' +\
  581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  582            'tags: ' + repr(self.tags) + ' ' +\
  583            'token: ' + repr(self.token) + ' ' +\
  584            '>'
  585
  586    def to_dict(self):
  587        return {
  588            'bind_interface': self.bind_interface,
  589            'egress_filter': self.egress_filter,
  590            'healthcheck_namespace': self.healthcheck_namespace,
  591            'healthy': self.healthy,
  592            'hostname': self.hostname,
  593            'id': self.id,
  594            'name': self.name,
  595            'port': self.port,
  596            'port_override': self.port_override,
  597            'secret_store_id': self.secret_store_id,
  598            'tags': self.tags,
  599            'token': self.token,
  600        }
  601
  602    @classmethod
  603    def from_dict(cls, d):
  604        return cls(
  605            bind_interface=d.get('bind_interface'),
  606            egress_filter=d.get('egress_filter'),
  607            healthcheck_namespace=d.get('healthcheck_namespace'),
  608            healthy=d.get('healthy'),
  609            hostname=d.get('hostname'),
  610            id=d.get('id'),
  611            name=d.get('name'),
  612            port=d.get('port'),
  613            port_override=d.get('port_override'),
  614            secret_store_id=d.get('secret_store_id'),
  615            tags=d.get('tags'),
  616            token=d.get('token'),
  617        )
  618
  619
  620class AKSUserImpersonation:
  621    '''
  622
  623    '''
  624    __slots__ = [
  625        'bind_interface',
  626        'certificate_authority',
  627        'client_certificate',
  628        'client_key',
  629        'egress_filter',
  630        'healthcheck_namespace',
  631        'healthy',
  632        'hostname',
  633        'id',
  634        'name',
  635        'port',
  636        'port_override',
  637        'secret_store_id',
  638        'tags',
  639    ]
  640
  641    def __init__(
  642        self,
  643        bind_interface=None,
  644        certificate_authority=None,
  645        client_certificate=None,
  646        client_key=None,
  647        egress_filter=None,
  648        healthcheck_namespace=None,
  649        healthy=None,
  650        hostname=None,
  651        id=None,
  652        name=None,
  653        port=None,
  654        port_override=None,
  655        secret_store_id=None,
  656        tags=None,
  657    ):
  658        self.bind_interface = bind_interface if bind_interface is not None else ''
  659        '''
  660         Bind interface
  661        '''
  662        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  663        '''
  664
  665        '''
  666        self.client_certificate = client_certificate if client_certificate is not None else ''
  667        '''
  668
  669        '''
  670        self.client_key = client_key if client_key is not None else ''
  671        '''
  672
  673        '''
  674        self.egress_filter = egress_filter if egress_filter is not None else ''
  675        '''
  676         A filter applied to the routing logic to pin datasource to nodes.
  677        '''
  678        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  679        '''
  680         The path used to check the health of your connection.  Defaults to `default`.
  681        '''
  682        self.healthy = healthy if healthy is not None else False
  683        '''
  684         True if the datasource is reachable and the credentials are valid.
  685        '''
  686        self.hostname = hostname if hostname is not None else ''
  687        '''
  688
  689        '''
  690        self.id = id if id is not None else ''
  691        '''
  692         Unique identifier of the Resource.
  693        '''
  694        self.name = name if name is not None else ''
  695        '''
  696         Unique human-readable name of the Resource.
  697        '''
  698        self.port = port if port is not None else 0
  699        '''
  700
  701        '''
  702        self.port_override = port_override if port_override is not None else 0
  703        '''
  704
  705        '''
  706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  707        '''
  708         ID of the secret store containing credentials for this resource, if any.
  709        '''
  710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  711        '''
  712         Tags is a map of key, value pairs.
  713        '''
  714
  715    def __repr__(self):
  716        return '<sdm.AKSUserImpersonation ' + \
  717            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  718            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  719            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  720            'client_key: ' + repr(self.client_key) + ' ' +\
  721            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  722            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  723            'healthy: ' + repr(self.healthy) + ' ' +\
  724            'hostname: ' + repr(self.hostname) + ' ' +\
  725            'id: ' + repr(self.id) + ' ' +\
  726            'name: ' + repr(self.name) + ' ' +\
  727            'port: ' + repr(self.port) + ' ' +\
  728            'port_override: ' + repr(self.port_override) + ' ' +\
  729            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  730            'tags: ' + repr(self.tags) + ' ' +\
  731            '>'
  732
  733    def to_dict(self):
  734        return {
  735            'bind_interface': self.bind_interface,
  736            'certificate_authority': self.certificate_authority,
  737            'client_certificate': self.client_certificate,
  738            'client_key': self.client_key,
  739            'egress_filter': self.egress_filter,
  740            'healthcheck_namespace': self.healthcheck_namespace,
  741            'healthy': self.healthy,
  742            'hostname': self.hostname,
  743            'id': self.id,
  744            'name': self.name,
  745            'port': self.port,
  746            'port_override': self.port_override,
  747            'secret_store_id': self.secret_store_id,
  748            'tags': self.tags,
  749        }
  750
  751    @classmethod
  752    def from_dict(cls, d):
  753        return cls(
  754            bind_interface=d.get('bind_interface'),
  755            certificate_authority=d.get('certificate_authority'),
  756            client_certificate=d.get('client_certificate'),
  757            client_key=d.get('client_key'),
  758            egress_filter=d.get('egress_filter'),
  759            healthcheck_namespace=d.get('healthcheck_namespace'),
  760            healthy=d.get('healthy'),
  761            hostname=d.get('hostname'),
  762            id=d.get('id'),
  763            name=d.get('name'),
  764            port=d.get('port'),
  765            port_override=d.get('port_override'),
  766            secret_store_id=d.get('secret_store_id'),
  767            tags=d.get('tags'),
  768        )
  769
  770
  771class AWS:
  772    '''
  773
  774    '''
  775    __slots__ = [
  776        'access_key',
  777        'bind_interface',
  778        'egress_filter',
  779        'healthcheck_region',
  780        'healthy',
  781        'id',
  782        'name',
  783        'role_arn',
  784        'role_external_id',
  785        'secret_access_key',
  786        'secret_store_id',
  787        'tags',
  788    ]
  789
  790    def __init__(
  791        self,
  792        access_key=None,
  793        bind_interface=None,
  794        egress_filter=None,
  795        healthcheck_region=None,
  796        healthy=None,
  797        id=None,
  798        name=None,
  799        role_arn=None,
  800        role_external_id=None,
  801        secret_access_key=None,
  802        secret_store_id=None,
  803        tags=None,
  804    ):
  805        self.access_key = access_key if access_key is not None else ''
  806        '''
  807
  808        '''
  809        self.bind_interface = bind_interface if bind_interface is not None else ''
  810        '''
  811         Bind interface
  812        '''
  813        self.egress_filter = egress_filter if egress_filter is not None else ''
  814        '''
  815         A filter applied to the routing logic to pin datasource to nodes.
  816        '''
  817        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  818        '''
  819
  820        '''
  821        self.healthy = healthy if healthy is not None else False
  822        '''
  823         True if the datasource is reachable and the credentials are valid.
  824        '''
  825        self.id = id if id is not None else ''
  826        '''
  827         Unique identifier of the Resource.
  828        '''
  829        self.name = name if name is not None else ''
  830        '''
  831         Unique human-readable name of the Resource.
  832        '''
  833        self.role_arn = role_arn if role_arn is not None else ''
  834        '''
  835
  836        '''
  837        self.role_external_id = role_external_id if role_external_id is not None else ''
  838        '''
  839
  840        '''
  841        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  842        '''
  843
  844        '''
  845        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  846        '''
  847         ID of the secret store containing credentials for this resource, if any.
  848        '''
  849        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  850        '''
  851         Tags is a map of key, value pairs.
  852        '''
  853
  854    def __repr__(self):
  855        return '<sdm.AWS ' + \
  856            'access_key: ' + repr(self.access_key) + ' ' +\
  857            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  858            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  859            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  860            'healthy: ' + repr(self.healthy) + ' ' +\
  861            'id: ' + repr(self.id) + ' ' +\
  862            'name: ' + repr(self.name) + ' ' +\
  863            'role_arn: ' + repr(self.role_arn) + ' ' +\
  864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  867            'tags: ' + repr(self.tags) + ' ' +\
  868            '>'
  869
  870    def to_dict(self):
  871        return {
  872            'access_key': self.access_key,
  873            'bind_interface': self.bind_interface,
  874            'egress_filter': self.egress_filter,
  875            'healthcheck_region': self.healthcheck_region,
  876            'healthy': self.healthy,
  877            'id': self.id,
  878            'name': self.name,
  879            'role_arn': self.role_arn,
  880            'role_external_id': self.role_external_id,
  881            'secret_access_key': self.secret_access_key,
  882            'secret_store_id': self.secret_store_id,
  883            'tags': self.tags,
  884        }
  885
  886    @classmethod
  887    def from_dict(cls, d):
  888        return cls(
  889            access_key=d.get('access_key'),
  890            bind_interface=d.get('bind_interface'),
  891            egress_filter=d.get('egress_filter'),
  892            healthcheck_region=d.get('healthcheck_region'),
  893            healthy=d.get('healthy'),
  894            id=d.get('id'),
  895            name=d.get('name'),
  896            role_arn=d.get('role_arn'),
  897            role_external_id=d.get('role_external_id'),
  898            secret_access_key=d.get('secret_access_key'),
  899            secret_store_id=d.get('secret_store_id'),
  900            tags=d.get('tags'),
  901        )
  902
  903
  904class AWSStore:
  905    '''
  906
  907    '''
  908    __slots__ = [
  909        'id',
  910        'name',
  911        'region',
  912        'tags',
  913    ]
  914
  915    def __init__(
  916        self,
  917        id=None,
  918        name=None,
  919        region=None,
  920        tags=None,
  921    ):
  922        self.id = id if id is not None else ''
  923        '''
  924         Unique identifier of the SecretStore.
  925        '''
  926        self.name = name if name is not None else ''
  927        '''
  928         Unique human-readable name of the SecretStore.
  929        '''
  930        self.region = region if region is not None else ''
  931        '''
  932
  933        '''
  934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  935        '''
  936         Tags is a map of key, value pairs.
  937        '''
  938
  939    def __repr__(self):
  940        return '<sdm.AWSStore ' + \
  941            'id: ' + repr(self.id) + ' ' +\
  942            'name: ' + repr(self.name) + ' ' +\
  943            'region: ' + repr(self.region) + ' ' +\
  944            'tags: ' + repr(self.tags) + ' ' +\
  945            '>'
  946
  947    def to_dict(self):
  948        return {
  949            'id': self.id,
  950            'name': self.name,
  951            'region': self.region,
  952            'tags': self.tags,
  953        }
  954
  955    @classmethod
  956    def from_dict(cls, d):
  957        return cls(
  958            id=d.get('id'),
  959            name=d.get('name'),
  960            region=d.get('region'),
  961            tags=d.get('tags'),
  962        )
  963
  964
  965class AccountAttachment:
  966    '''
  967     AccountAttachments assign an account to a role.
  968    '''
  969    __slots__ = [
  970        'account_id',
  971        'id',
  972        'role_id',
  973    ]
  974
  975    def __init__(
  976        self,
  977        account_id=None,
  978        id=None,
  979        role_id=None,
  980    ):
  981        self.account_id = account_id if account_id is not None else ''
  982        '''
  983         The id of the account of this AccountAttachment.
  984        '''
  985        self.id = id if id is not None else ''
  986        '''
  987         Unique identifier of the AccountAttachment.
  988        '''
  989        self.role_id = role_id if role_id is not None else ''
  990        '''
  991         The id of the attached role of this AccountAttachment.
  992        '''
  993
  994    def __repr__(self):
  995        return '<sdm.AccountAttachment ' + \
  996            'account_id: ' + repr(self.account_id) + ' ' +\
  997            'id: ' + repr(self.id) + ' ' +\
  998            'role_id: ' + repr(self.role_id) + ' ' +\
  999            '>'
 1000
 1001    def to_dict(self):
 1002        return {
 1003            'account_id': self.account_id,
 1004            'id': self.id,
 1005            'role_id': self.role_id,
 1006        }
 1007
 1008    @classmethod
 1009    def from_dict(cls, d):
 1010        return cls(
 1011            account_id=d.get('account_id'),
 1012            id=d.get('id'),
 1013            role_id=d.get('role_id'),
 1014        )
 1015
 1016
 1017class AccountAttachmentCreateResponse:
 1018    '''
 1019     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1020    '''
 1021    __slots__ = [
 1022        'account_attachment',
 1023        'meta',
 1024        'rate_limit',
 1025    ]
 1026
 1027    def __init__(
 1028        self,
 1029        account_attachment=None,
 1030        meta=None,
 1031        rate_limit=None,
 1032    ):
 1033        self.account_attachment = account_attachment if account_attachment is not None else None
 1034        '''
 1035         The created AccountAttachment.
 1036        '''
 1037        self.meta = meta if meta is not None else None
 1038        '''
 1039         Reserved for future use.
 1040        '''
 1041        self.rate_limit = rate_limit if rate_limit is not None else None
 1042        '''
 1043         Rate limit information.
 1044        '''
 1045
 1046    def __repr__(self):
 1047        return '<sdm.AccountAttachmentCreateResponse ' + \
 1048            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1049            'meta: ' + repr(self.meta) + ' ' +\
 1050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1051            '>'
 1052
 1053    def to_dict(self):
 1054        return {
 1055            'account_attachment': self.account_attachment,
 1056            'meta': self.meta,
 1057            'rate_limit': self.rate_limit,
 1058        }
 1059
 1060    @classmethod
 1061    def from_dict(cls, d):
 1062        return cls(
 1063            account_attachment=d.get('account_attachment'),
 1064            meta=d.get('meta'),
 1065            rate_limit=d.get('rate_limit'),
 1066        )
 1067
 1068
 1069class AccountAttachmentDeleteResponse:
 1070    '''
 1071     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1072    '''
 1073    __slots__ = [
 1074        'meta',
 1075        'rate_limit',
 1076    ]
 1077
 1078    def __init__(
 1079        self,
 1080        meta=None,
 1081        rate_limit=None,
 1082    ):
 1083        self.meta = meta if meta is not None else None
 1084        '''
 1085         Reserved for future use.
 1086        '''
 1087        self.rate_limit = rate_limit if rate_limit is not None else None
 1088        '''
 1089         Rate limit information.
 1090        '''
 1091
 1092    def __repr__(self):
 1093        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1094            'meta: ' + repr(self.meta) + ' ' +\
 1095            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1096            '>'
 1097
 1098    def to_dict(self):
 1099        return {
 1100            'meta': self.meta,
 1101            'rate_limit': self.rate_limit,
 1102        }
 1103
 1104    @classmethod
 1105    def from_dict(cls, d):
 1106        return cls(
 1107            meta=d.get('meta'),
 1108            rate_limit=d.get('rate_limit'),
 1109        )
 1110
 1111
 1112class AccountAttachmentGetResponse:
 1113    '''
 1114     AccountAttachmentGetResponse returns a requested AccountAttachment.
 1115    '''
 1116    __slots__ = [
 1117        'account_attachment',
 1118        'meta',
 1119        'rate_limit',
 1120    ]
 1121
 1122    def __init__(
 1123        self,
 1124        account_attachment=None,
 1125        meta=None,
 1126        rate_limit=None,
 1127    ):
 1128        self.account_attachment = account_attachment if account_attachment is not None else None
 1129        '''
 1130         The requested AccountAttachment.
 1131        '''
 1132        self.meta = meta if meta is not None else None
 1133        '''
 1134         Reserved for future use.
 1135        '''
 1136        self.rate_limit = rate_limit if rate_limit is not None else None
 1137        '''
 1138         Rate limit information.
 1139        '''
 1140
 1141    def __repr__(self):
 1142        return '<sdm.AccountAttachmentGetResponse ' + \
 1143            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1144            'meta: ' + repr(self.meta) + ' ' +\
 1145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1146            '>'
 1147
 1148    def to_dict(self):
 1149        return {
 1150            'account_attachment': self.account_attachment,
 1151            'meta': self.meta,
 1152            'rate_limit': self.rate_limit,
 1153        }
 1154
 1155    @classmethod
 1156    def from_dict(cls, d):
 1157        return cls(
 1158            account_attachment=d.get('account_attachment'),
 1159            meta=d.get('meta'),
 1160            rate_limit=d.get('rate_limit'),
 1161        )
 1162
 1163
 1164class AccountCreateResponse:
 1165    '''
 1166     AccountCreateResponse reports how the Accounts were created in the system.
 1167    '''
 1168    __slots__ = [
 1169        'account',
 1170        'meta',
 1171        'rate_limit',
 1172        'token',
 1173    ]
 1174
 1175    def __init__(
 1176        self,
 1177        account=None,
 1178        meta=None,
 1179        rate_limit=None,
 1180        token=None,
 1181    ):
 1182        self.account = account if account is not None else None
 1183        '''
 1184         The created Account.
 1185        '''
 1186        self.meta = meta if meta is not None else None
 1187        '''
 1188         Reserved for future use.
 1189        '''
 1190        self.rate_limit = rate_limit if rate_limit is not None else None
 1191        '''
 1192         Rate limit information.
 1193        '''
 1194        self.token = token if token is not None else ''
 1195        '''
 1196         The auth token generated for the Account. The Account will use this token to
 1197         authenticate with the strongDM API.
 1198        '''
 1199
 1200    def __repr__(self):
 1201        return '<sdm.AccountCreateResponse ' + \
 1202            'account: ' + repr(self.account) + ' ' +\
 1203            'meta: ' + repr(self.meta) + ' ' +\
 1204            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1205            'token: ' + repr(self.token) + ' ' +\
 1206            '>'
 1207
 1208    def to_dict(self):
 1209        return {
 1210            'account': self.account,
 1211            'meta': self.meta,
 1212            'rate_limit': self.rate_limit,
 1213            'token': self.token,
 1214        }
 1215
 1216    @classmethod
 1217    def from_dict(cls, d):
 1218        return cls(
 1219            account=d.get('account'),
 1220            meta=d.get('meta'),
 1221            rate_limit=d.get('rate_limit'),
 1222            token=d.get('token'),
 1223        )
 1224
 1225
 1226class AccountDeleteResponse:
 1227    '''
 1228     AccountDeleteResponse returns information about a Account that was deleted.
 1229    '''
 1230    __slots__ = [
 1231        'meta',
 1232        'rate_limit',
 1233    ]
 1234
 1235    def __init__(
 1236        self,
 1237        meta=None,
 1238        rate_limit=None,
 1239    ):
 1240        self.meta = meta if meta is not None else None
 1241        '''
 1242         Reserved for future use.
 1243        '''
 1244        self.rate_limit = rate_limit if rate_limit is not None else None
 1245        '''
 1246         Rate limit information.
 1247        '''
 1248
 1249    def __repr__(self):
 1250        return '<sdm.AccountDeleteResponse ' + \
 1251            'meta: ' + repr(self.meta) + ' ' +\
 1252            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1253            '>'
 1254
 1255    def to_dict(self):
 1256        return {
 1257            'meta': self.meta,
 1258            'rate_limit': self.rate_limit,
 1259        }
 1260
 1261    @classmethod
 1262    def from_dict(cls, d):
 1263        return cls(
 1264            meta=d.get('meta'),
 1265            rate_limit=d.get('rate_limit'),
 1266        )
 1267
 1268
 1269class AccountGetResponse:
 1270    '''
 1271     AccountGetResponse returns a requested Account.
 1272    '''
 1273    __slots__ = [
 1274        'account',
 1275        'meta',
 1276        'rate_limit',
 1277    ]
 1278
 1279    def __init__(
 1280        self,
 1281        account=None,
 1282        meta=None,
 1283        rate_limit=None,
 1284    ):
 1285        self.account = account if account is not None else None
 1286        '''
 1287         The requested Account.
 1288        '''
 1289        self.meta = meta if meta is not None else None
 1290        '''
 1291         Reserved for future use.
 1292        '''
 1293        self.rate_limit = rate_limit if rate_limit is not None else None
 1294        '''
 1295         Rate limit information.
 1296        '''
 1297
 1298    def __repr__(self):
 1299        return '<sdm.AccountGetResponse ' + \
 1300            'account: ' + repr(self.account) + ' ' +\
 1301            'meta: ' + repr(self.meta) + ' ' +\
 1302            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1303            '>'
 1304
 1305    def to_dict(self):
 1306        return {
 1307            'account': self.account,
 1308            'meta': self.meta,
 1309            'rate_limit': self.rate_limit,
 1310        }
 1311
 1312    @classmethod
 1313    def from_dict(cls, d):
 1314        return cls(
 1315            account=d.get('account'),
 1316            meta=d.get('meta'),
 1317            rate_limit=d.get('rate_limit'),
 1318        )
 1319
 1320
 1321class AccountGrant:
 1322    '''
 1323     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1324    '''
 1325    __slots__ = [
 1326        'account_id',
 1327        'id',
 1328        'resource_id',
 1329        'start_from',
 1330        'valid_until',
 1331    ]
 1332
 1333    def __init__(
 1334        self,
 1335        account_id=None,
 1336        id=None,
 1337        resource_id=None,
 1338        start_from=None,
 1339        valid_until=None,
 1340    ):
 1341        self.account_id = account_id if account_id is not None else ''
 1342        '''
 1343         The account id of this AccountGrant.
 1344        '''
 1345        self.id = id if id is not None else ''
 1346        '''
 1347         Unique identifier of the AccountGrant.
 1348        '''
 1349        self.resource_id = resource_id if resource_id is not None else ''
 1350        '''
 1351         The resource id of this AccountGrant.
 1352        '''
 1353        self.start_from = start_from if start_from is not None else None
 1354        '''
 1355         The timestamp when the resource will be granted. Optional. Both start_at
 1356         and end_at must be defined together, or not defined at all.
 1357        '''
 1358        self.valid_until = valid_until if valid_until is not None else None
 1359        '''
 1360         The timestamp when the resource grant will expire. Optional. Both
 1361         start_at and end_at must be defined together, or not defined at all.
 1362        '''
 1363
 1364    def __repr__(self):
 1365        return '<sdm.AccountGrant ' + \
 1366            'account_id: ' + repr(self.account_id) + ' ' +\
 1367            'id: ' + repr(self.id) + ' ' +\
 1368            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1369            'start_from: ' + repr(self.start_from) + ' ' +\
 1370            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1371            '>'
 1372
 1373    def to_dict(self):
 1374        return {
 1375            'account_id': self.account_id,
 1376            'id': self.id,
 1377            'resource_id': self.resource_id,
 1378            'start_from': self.start_from,
 1379            'valid_until': self.valid_until,
 1380        }
 1381
 1382    @classmethod
 1383    def from_dict(cls, d):
 1384        return cls(
 1385            account_id=d.get('account_id'),
 1386            id=d.get('id'),
 1387            resource_id=d.get('resource_id'),
 1388            start_from=d.get('start_from'),
 1389            valid_until=d.get('valid_until'),
 1390        )
 1391
 1392
 1393class AccountGrantCreateResponse:
 1394    '''
 1395     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1396    '''
 1397    __slots__ = [
 1398        'account_grant',
 1399        'meta',
 1400        'rate_limit',
 1401    ]
 1402
 1403    def __init__(
 1404        self,
 1405        account_grant=None,
 1406        meta=None,
 1407        rate_limit=None,
 1408    ):
 1409        self.account_grant = account_grant if account_grant is not None else None
 1410        '''
 1411         The created AccountGrant.
 1412        '''
 1413        self.meta = meta if meta is not None else None
 1414        '''
 1415         Reserved for future use.
 1416        '''
 1417        self.rate_limit = rate_limit if rate_limit is not None else None
 1418        '''
 1419         Rate limit information.
 1420        '''
 1421
 1422    def __repr__(self):
 1423        return '<sdm.AccountGrantCreateResponse ' + \
 1424            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1425            'meta: ' + repr(self.meta) + ' ' +\
 1426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1427            '>'
 1428
 1429    def to_dict(self):
 1430        return {
 1431            'account_grant': self.account_grant,
 1432            'meta': self.meta,
 1433            'rate_limit': self.rate_limit,
 1434        }
 1435
 1436    @classmethod
 1437    def from_dict(cls, d):
 1438        return cls(
 1439            account_grant=d.get('account_grant'),
 1440            meta=d.get('meta'),
 1441            rate_limit=d.get('rate_limit'),
 1442        )
 1443
 1444
 1445class AccountGrantDeleteResponse:
 1446    '''
 1447     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1448    '''
 1449    __slots__ = [
 1450        'meta',
 1451        'rate_limit',
 1452    ]
 1453
 1454    def __init__(
 1455        self,
 1456        meta=None,
 1457        rate_limit=None,
 1458    ):
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGrantDeleteResponse ' + \
 1470            'meta: ' + repr(self.meta) + ' ' +\
 1471            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1472            '>'
 1473
 1474    def to_dict(self):
 1475        return {
 1476            'meta': self.meta,
 1477            'rate_limit': self.rate_limit,
 1478        }
 1479
 1480    @classmethod
 1481    def from_dict(cls, d):
 1482        return cls(
 1483            meta=d.get('meta'),
 1484            rate_limit=d.get('rate_limit'),
 1485        )
 1486
 1487
 1488class AccountGrantGetResponse:
 1489    '''
 1490     AccountGrantGetResponse returns a requested AccountGrant.
 1491    '''
 1492    __slots__ = [
 1493        'account_grant',
 1494        'meta',
 1495        'rate_limit',
 1496    ]
 1497
 1498    def __init__(
 1499        self,
 1500        account_grant=None,
 1501        meta=None,
 1502        rate_limit=None,
 1503    ):
 1504        self.account_grant = account_grant if account_grant is not None else None
 1505        '''
 1506         The requested AccountGrant.
 1507        '''
 1508        self.meta = meta if meta is not None else None
 1509        '''
 1510         Reserved for future use.
 1511        '''
 1512        self.rate_limit = rate_limit if rate_limit is not None else None
 1513        '''
 1514         Rate limit information.
 1515        '''
 1516
 1517    def __repr__(self):
 1518        return '<sdm.AccountGrantGetResponse ' + \
 1519            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1520            'meta: ' + repr(self.meta) + ' ' +\
 1521            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1522            '>'
 1523
 1524    def to_dict(self):
 1525        return {
 1526            'account_grant': self.account_grant,
 1527            'meta': self.meta,
 1528            'rate_limit': self.rate_limit,
 1529        }
 1530
 1531    @classmethod
 1532    def from_dict(cls, d):
 1533        return cls(
 1534            account_grant=d.get('account_grant'),
 1535            meta=d.get('meta'),
 1536            rate_limit=d.get('rate_limit'),
 1537        )
 1538
 1539
 1540class AccountUpdateResponse:
 1541    '''
 1542     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1543     a AccountUpdateRequest.
 1544    '''
 1545    __slots__ = [
 1546        'account',
 1547        'meta',
 1548        'rate_limit',
 1549    ]
 1550
 1551    def __init__(
 1552        self,
 1553        account=None,
 1554        meta=None,
 1555        rate_limit=None,
 1556    ):
 1557        self.account = account if account is not None else None
 1558        '''
 1559         The updated Account.
 1560        '''
 1561        self.meta = meta if meta is not None else None
 1562        '''
 1563         Reserved for future use.
 1564        '''
 1565        self.rate_limit = rate_limit if rate_limit is not None else None
 1566        '''
 1567         Rate limit information.
 1568        '''
 1569
 1570    def __repr__(self):
 1571        return '<sdm.AccountUpdateResponse ' + \
 1572            'account: ' + repr(self.account) + ' ' +\
 1573            'meta: ' + repr(self.meta) + ' ' +\
 1574            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1575            '>'
 1576
 1577    def to_dict(self):
 1578        return {
 1579            'account': self.account,
 1580            'meta': self.meta,
 1581            'rate_limit': self.rate_limit,
 1582        }
 1583
 1584    @classmethod
 1585    def from_dict(cls, d):
 1586        return cls(
 1587            account=d.get('account'),
 1588            meta=d.get('meta'),
 1589            rate_limit=d.get('rate_limit'),
 1590        )
 1591
 1592
 1593class AmazonEKS:
 1594    '''
 1595
 1596    '''
 1597    __slots__ = [
 1598        'access_key',
 1599        'bind_interface',
 1600        'certificate_authority',
 1601        'cluster_name',
 1602        'egress_filter',
 1603        'endpoint',
 1604        'healthcheck_namespace',
 1605        'healthy',
 1606        'id',
 1607        'name',
 1608        'region',
 1609        'remote_identity_group_id',
 1610        'remote_identity_healthcheck_username',
 1611        'role_arn',
 1612        'role_external_id',
 1613        'secret_access_key',
 1614        'secret_store_id',
 1615        'tags',
 1616    ]
 1617
 1618    def __init__(
 1619        self,
 1620        access_key=None,
 1621        bind_interface=None,
 1622        certificate_authority=None,
 1623        cluster_name=None,
 1624        egress_filter=None,
 1625        endpoint=None,
 1626        healthcheck_namespace=None,
 1627        healthy=None,
 1628        id=None,
 1629        name=None,
 1630        region=None,
 1631        remote_identity_group_id=None,
 1632        remote_identity_healthcheck_username=None,
 1633        role_arn=None,
 1634        role_external_id=None,
 1635        secret_access_key=None,
 1636        secret_store_id=None,
 1637        tags=None,
 1638    ):
 1639        self.access_key = access_key if access_key is not None else ''
 1640        '''
 1641
 1642        '''
 1643        self.bind_interface = bind_interface if bind_interface is not None else ''
 1644        '''
 1645         Bind interface
 1646        '''
 1647        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1648        '''
 1649
 1650        '''
 1651        self.cluster_name = cluster_name if cluster_name is not None else ''
 1652        '''
 1653
 1654        '''
 1655        self.egress_filter = egress_filter if egress_filter is not None else ''
 1656        '''
 1657         A filter applied to the routing logic to pin datasource to nodes.
 1658        '''
 1659        self.endpoint = endpoint if endpoint is not None else ''
 1660        '''
 1661
 1662        '''
 1663        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1664        '''
 1665         The path used to check the health of your connection.  Defaults to `default`.
 1666        '''
 1667        self.healthy = healthy if healthy is not None else False
 1668        '''
 1669         True if the datasource is reachable and the credentials are valid.
 1670        '''
 1671        self.id = id if id is not None else ''
 1672        '''
 1673         Unique identifier of the Resource.
 1674        '''
 1675        self.name = name if name is not None else ''
 1676        '''
 1677         Unique human-readable name of the Resource.
 1678        '''
 1679        self.region = region if region is not None else ''
 1680        '''
 1681
 1682        '''
 1683        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1684        '''
 1685
 1686        '''
 1687        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1688        '''
 1689
 1690        '''
 1691        self.role_arn = role_arn if role_arn is not None else ''
 1692        '''
 1693
 1694        '''
 1695        self.role_external_id = role_external_id if role_external_id is not None else ''
 1696        '''
 1697
 1698        '''
 1699        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1700        '''
 1701
 1702        '''
 1703        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1704        '''
 1705         ID of the secret store containing credentials for this resource, if any.
 1706        '''
 1707        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1708        '''
 1709         Tags is a map of key, value pairs.
 1710        '''
 1711
 1712    def __repr__(self):
 1713        return '<sdm.AmazonEKS ' + \
 1714            'access_key: ' + repr(self.access_key) + ' ' +\
 1715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1716            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1717            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1719            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1720            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1721            'healthy: ' + repr(self.healthy) + ' ' +\
 1722            'id: ' + repr(self.id) + ' ' +\
 1723            'name: ' + repr(self.name) + ' ' +\
 1724            'region: ' + repr(self.region) + ' ' +\
 1725            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1726            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1727            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1728            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1729            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1731            'tags: ' + repr(self.tags) + ' ' +\
 1732            '>'
 1733
 1734    def to_dict(self):
 1735        return {
 1736            'access_key': self.access_key,
 1737            'bind_interface': self.bind_interface,
 1738            'certificate_authority': self.certificate_authority,
 1739            'cluster_name': self.cluster_name,
 1740            'egress_filter': self.egress_filter,
 1741            'endpoint': self.endpoint,
 1742            'healthcheck_namespace': self.healthcheck_namespace,
 1743            'healthy': self.healthy,
 1744            'id': self.id,
 1745            'name': self.name,
 1746            'region': self.region,
 1747            'remote_identity_group_id': self.remote_identity_group_id,
 1748            'remote_identity_healthcheck_username':
 1749            self.remote_identity_healthcheck_username,
 1750            'role_arn': self.role_arn,
 1751            'role_external_id': self.role_external_id,
 1752            'secret_access_key': self.secret_access_key,
 1753            'secret_store_id': self.secret_store_id,
 1754            'tags': self.tags,
 1755        }
 1756
 1757    @classmethod
 1758    def from_dict(cls, d):
 1759        return cls(
 1760            access_key=d.get('access_key'),
 1761            bind_interface=d.get('bind_interface'),
 1762            certificate_authority=d.get('certificate_authority'),
 1763            cluster_name=d.get('cluster_name'),
 1764            egress_filter=d.get('egress_filter'),
 1765            endpoint=d.get('endpoint'),
 1766            healthcheck_namespace=d.get('healthcheck_namespace'),
 1767            healthy=d.get('healthy'),
 1768            id=d.get('id'),
 1769            name=d.get('name'),
 1770            region=d.get('region'),
 1771            remote_identity_group_id=d.get('remote_identity_group_id'),
 1772            remote_identity_healthcheck_username=d.get(
 1773                'remote_identity_healthcheck_username'),
 1774            role_arn=d.get('role_arn'),
 1775            role_external_id=d.get('role_external_id'),
 1776            secret_access_key=d.get('secret_access_key'),
 1777            secret_store_id=d.get('secret_store_id'),
 1778            tags=d.get('tags'),
 1779        )
 1780
 1781
 1782class AmazonEKSUserImpersonation:
 1783    '''
 1784
 1785    '''
 1786    __slots__ = [
 1787        'access_key',
 1788        'bind_interface',
 1789        'certificate_authority',
 1790        'cluster_name',
 1791        'egress_filter',
 1792        'endpoint',
 1793        'healthcheck_namespace',
 1794        'healthy',
 1795        'id',
 1796        'name',
 1797        'region',
 1798        'role_arn',
 1799        'role_external_id',
 1800        'secret_access_key',
 1801        'secret_store_id',
 1802        'tags',
 1803    ]
 1804
 1805    def __init__(
 1806        self,
 1807        access_key=None,
 1808        bind_interface=None,
 1809        certificate_authority=None,
 1810        cluster_name=None,
 1811        egress_filter=None,
 1812        endpoint=None,
 1813        healthcheck_namespace=None,
 1814        healthy=None,
 1815        id=None,
 1816        name=None,
 1817        region=None,
 1818        role_arn=None,
 1819        role_external_id=None,
 1820        secret_access_key=None,
 1821        secret_store_id=None,
 1822        tags=None,
 1823    ):
 1824        self.access_key = access_key if access_key is not None else ''
 1825        '''
 1826
 1827        '''
 1828        self.bind_interface = bind_interface if bind_interface is not None else ''
 1829        '''
 1830         Bind interface
 1831        '''
 1832        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1833        '''
 1834
 1835        '''
 1836        self.cluster_name = cluster_name if cluster_name is not None else ''
 1837        '''
 1838
 1839        '''
 1840        self.egress_filter = egress_filter if egress_filter is not None else ''
 1841        '''
 1842         A filter applied to the routing logic to pin datasource to nodes.
 1843        '''
 1844        self.endpoint = endpoint if endpoint is not None else ''
 1845        '''
 1846
 1847        '''
 1848        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1849        '''
 1850         The path used to check the health of your connection.  Defaults to `default`.
 1851        '''
 1852        self.healthy = healthy if healthy is not None else False
 1853        '''
 1854         True if the datasource is reachable and the credentials are valid.
 1855        '''
 1856        self.id = id if id is not None else ''
 1857        '''
 1858         Unique identifier of the Resource.
 1859        '''
 1860        self.name = name if name is not None else ''
 1861        '''
 1862         Unique human-readable name of the Resource.
 1863        '''
 1864        self.region = region if region is not None else ''
 1865        '''
 1866
 1867        '''
 1868        self.role_arn = role_arn if role_arn is not None else ''
 1869        '''
 1870
 1871        '''
 1872        self.role_external_id = role_external_id if role_external_id is not None else ''
 1873        '''
 1874
 1875        '''
 1876        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1877        '''
 1878
 1879        '''
 1880        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1881        '''
 1882         ID of the secret store containing credentials for this resource, if any.
 1883        '''
 1884        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1885        '''
 1886         Tags is a map of key, value pairs.
 1887        '''
 1888
 1889    def __repr__(self):
 1890        return '<sdm.AmazonEKSUserImpersonation ' + \
 1891            'access_key: ' + repr(self.access_key) + ' ' +\
 1892            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1893            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1894            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1895            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1896            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1897            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1898            'healthy: ' + repr(self.healthy) + ' ' +\
 1899            'id: ' + repr(self.id) + ' ' +\
 1900            'name: ' + repr(self.name) + ' ' +\
 1901            'region: ' + repr(self.region) + ' ' +\
 1902            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1903            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1904            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1905            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1906            'tags: ' + repr(self.tags) + ' ' +\
 1907            '>'
 1908
 1909    def to_dict(self):
 1910        return {
 1911            'access_key': self.access_key,
 1912            'bind_interface': self.bind_interface,
 1913            'certificate_authority': self.certificate_authority,
 1914            'cluster_name': self.cluster_name,
 1915            'egress_filter': self.egress_filter,
 1916            'endpoint': self.endpoint,
 1917            'healthcheck_namespace': self.healthcheck_namespace,
 1918            'healthy': self.healthy,
 1919            'id': self.id,
 1920            'name': self.name,
 1921            'region': self.region,
 1922            'role_arn': self.role_arn,
 1923            'role_external_id': self.role_external_id,
 1924            'secret_access_key': self.secret_access_key,
 1925            'secret_store_id': self.secret_store_id,
 1926            'tags': self.tags,
 1927        }
 1928
 1929    @classmethod
 1930    def from_dict(cls, d):
 1931        return cls(
 1932            access_key=d.get('access_key'),
 1933            bind_interface=d.get('bind_interface'),
 1934            certificate_authority=d.get('certificate_authority'),
 1935            cluster_name=d.get('cluster_name'),
 1936            egress_filter=d.get('egress_filter'),
 1937            endpoint=d.get('endpoint'),
 1938            healthcheck_namespace=d.get('healthcheck_namespace'),
 1939            healthy=d.get('healthy'),
 1940            id=d.get('id'),
 1941            name=d.get('name'),
 1942            region=d.get('region'),
 1943            role_arn=d.get('role_arn'),
 1944            role_external_id=d.get('role_external_id'),
 1945            secret_access_key=d.get('secret_access_key'),
 1946            secret_store_id=d.get('secret_store_id'),
 1947            tags=d.get('tags'),
 1948        )
 1949
 1950
 1951class AmazonES:
 1952    '''
 1953
 1954    '''
 1955    __slots__ = [
 1956        'access_key',
 1957        'bind_interface',
 1958        'egress_filter',
 1959        'endpoint',
 1960        'healthy',
 1961        'id',
 1962        'name',
 1963        'port_override',
 1964        'region',
 1965        'role_arn',
 1966        'role_external_id',
 1967        'secret_access_key',
 1968        'secret_store_id',
 1969        'tags',
 1970    ]
 1971
 1972    def __init__(
 1973        self,
 1974        access_key=None,
 1975        bind_interface=None,
 1976        egress_filter=None,
 1977        endpoint=None,
 1978        healthy=None,
 1979        id=None,
 1980        name=None,
 1981        port_override=None,
 1982        region=None,
 1983        role_arn=None,
 1984        role_external_id=None,
 1985        secret_access_key=None,
 1986        secret_store_id=None,
 1987        tags=None,
 1988    ):
 1989        self.access_key = access_key if access_key is not None else ''
 1990        '''
 1991
 1992        '''
 1993        self.bind_interface = bind_interface if bind_interface is not None else ''
 1994        '''
 1995         Bind interface
 1996        '''
 1997        self.egress_filter = egress_filter if egress_filter is not None else ''
 1998        '''
 1999         A filter applied to the routing logic to pin datasource to nodes.
 2000        '''
 2001        self.endpoint = endpoint if endpoint is not None else ''
 2002        '''
 2003
 2004        '''
 2005        self.healthy = healthy if healthy is not None else False
 2006        '''
 2007         True if the datasource is reachable and the credentials are valid.
 2008        '''
 2009        self.id = id if id is not None else ''
 2010        '''
 2011         Unique identifier of the Resource.
 2012        '''
 2013        self.name = name if name is not None else ''
 2014        '''
 2015         Unique human-readable name of the Resource.
 2016        '''
 2017        self.port_override = port_override if port_override is not None else 0
 2018        '''
 2019
 2020        '''
 2021        self.region = region if region is not None else ''
 2022        '''
 2023
 2024        '''
 2025        self.role_arn = role_arn if role_arn is not None else ''
 2026        '''
 2027
 2028        '''
 2029        self.role_external_id = role_external_id if role_external_id is not None else ''
 2030        '''
 2031
 2032        '''
 2033        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2034        '''
 2035
 2036        '''
 2037        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2038        '''
 2039         ID of the secret store containing credentials for this resource, if any.
 2040        '''
 2041        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2042        '''
 2043         Tags is a map of key, value pairs.
 2044        '''
 2045
 2046    def __repr__(self):
 2047        return '<sdm.AmazonES ' + \
 2048            'access_key: ' + repr(self.access_key) + ' ' +\
 2049            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2050            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2051            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2052            'healthy: ' + repr(self.healthy) + ' ' +\
 2053            'id: ' + repr(self.id) + ' ' +\
 2054            'name: ' + repr(self.name) + ' ' +\
 2055            'port_override: ' + repr(self.port_override) + ' ' +\
 2056            'region: ' + repr(self.region) + ' ' +\
 2057            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2058            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2059            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2060            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2061            'tags: ' + repr(self.tags) + ' ' +\
 2062            '>'
 2063
 2064    def to_dict(self):
 2065        return {
 2066            'access_key': self.access_key,
 2067            'bind_interface': self.bind_interface,
 2068            'egress_filter': self.egress_filter,
 2069            'endpoint': self.endpoint,
 2070            'healthy': self.healthy,
 2071            'id': self.id,
 2072            'name': self.name,
 2073            'port_override': self.port_override,
 2074            'region': self.region,
 2075            'role_arn': self.role_arn,
 2076            'role_external_id': self.role_external_id,
 2077            'secret_access_key': self.secret_access_key,
 2078            'secret_store_id': self.secret_store_id,
 2079            'tags': self.tags,
 2080        }
 2081
 2082    @classmethod
 2083    def from_dict(cls, d):
 2084        return cls(
 2085            access_key=d.get('access_key'),
 2086            bind_interface=d.get('bind_interface'),
 2087            egress_filter=d.get('egress_filter'),
 2088            endpoint=d.get('endpoint'),
 2089            healthy=d.get('healthy'),
 2090            id=d.get('id'),
 2091            name=d.get('name'),
 2092            port_override=d.get('port_override'),
 2093            region=d.get('region'),
 2094            role_arn=d.get('role_arn'),
 2095            role_external_id=d.get('role_external_id'),
 2096            secret_access_key=d.get('secret_access_key'),
 2097            secret_store_id=d.get('secret_store_id'),
 2098            tags=d.get('tags'),
 2099        )
 2100
 2101
 2102class AmazonMQAMQP091:
 2103    '''
 2104
 2105    '''
 2106    __slots__ = [
 2107        'bind_interface',
 2108        'egress_filter',
 2109        'healthy',
 2110        'hostname',
 2111        'id',
 2112        'name',
 2113        'password',
 2114        'port',
 2115        'port_override',
 2116        'secret_store_id',
 2117        'tags',
 2118        'tls_required',
 2119        'username',
 2120    ]
 2121
 2122    def __init__(
 2123        self,
 2124        bind_interface=None,
 2125        egress_filter=None,
 2126        healthy=None,
 2127        hostname=None,
 2128        id=None,
 2129        name=None,
 2130        password=None,
 2131        port=None,
 2132        port_override=None,
 2133        secret_store_id=None,
 2134        tags=None,
 2135        tls_required=None,
 2136        username=None,
 2137    ):
 2138        self.bind_interface = bind_interface if bind_interface is not None else ''
 2139        '''
 2140         Bind interface
 2141        '''
 2142        self.egress_filter = egress_filter if egress_filter is not None else ''
 2143        '''
 2144         A filter applied to the routing logic to pin datasource to nodes.
 2145        '''
 2146        self.healthy = healthy if healthy is not None else False
 2147        '''
 2148         True if the datasource is reachable and the credentials are valid.
 2149        '''
 2150        self.hostname = hostname if hostname is not None else ''
 2151        '''
 2152
 2153        '''
 2154        self.id = id if id is not None else ''
 2155        '''
 2156         Unique identifier of the Resource.
 2157        '''
 2158        self.name = name if name is not None else ''
 2159        '''
 2160         Unique human-readable name of the Resource.
 2161        '''
 2162        self.password = password if password is not None else ''
 2163        '''
 2164
 2165        '''
 2166        self.port = port if port is not None else 0
 2167        '''
 2168
 2169        '''
 2170        self.port_override = port_override if port_override is not None else 0
 2171        '''
 2172
 2173        '''
 2174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2175        '''
 2176         ID of the secret store containing credentials for this resource, if any.
 2177        '''
 2178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2179        '''
 2180         Tags is a map of key, value pairs.
 2181        '''
 2182        self.tls_required = tls_required if tls_required is not None else False
 2183        '''
 2184
 2185        '''
 2186        self.username = username if username is not None else ''
 2187        '''
 2188
 2189        '''
 2190
 2191    def __repr__(self):
 2192        return '<sdm.AmazonMQAMQP091 ' + \
 2193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2195            'healthy: ' + repr(self.healthy) + ' ' +\
 2196            'hostname: ' + repr(self.hostname) + ' ' +\
 2197            'id: ' + repr(self.id) + ' ' +\
 2198            'name: ' + repr(self.name) + ' ' +\
 2199            'password: ' + repr(self.password) + ' ' +\
 2200            'port: ' + repr(self.port) + ' ' +\
 2201            'port_override: ' + repr(self.port_override) + ' ' +\
 2202            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2203            'tags: ' + repr(self.tags) + ' ' +\
 2204            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2205            'username: ' + repr(self.username) + ' ' +\
 2206            '>'
 2207
 2208    def to_dict(self):
 2209        return {
 2210            'bind_interface': self.bind_interface,
 2211            'egress_filter': self.egress_filter,
 2212            'healthy': self.healthy,
 2213            'hostname': self.hostname,
 2214            'id': self.id,
 2215            'name': self.name,
 2216            'password': self.password,
 2217            'port': self.port,
 2218            'port_override': self.port_override,
 2219            'secret_store_id': self.secret_store_id,
 2220            'tags': self.tags,
 2221            'tls_required': self.tls_required,
 2222            'username': self.username,
 2223        }
 2224
 2225    @classmethod
 2226    def from_dict(cls, d):
 2227        return cls(
 2228            bind_interface=d.get('bind_interface'),
 2229            egress_filter=d.get('egress_filter'),
 2230            healthy=d.get('healthy'),
 2231            hostname=d.get('hostname'),
 2232            id=d.get('id'),
 2233            name=d.get('name'),
 2234            password=d.get('password'),
 2235            port=d.get('port'),
 2236            port_override=d.get('port_override'),
 2237            secret_store_id=d.get('secret_store_id'),
 2238            tags=d.get('tags'),
 2239            tls_required=d.get('tls_required'),
 2240            username=d.get('username'),
 2241        )
 2242
 2243
 2244class Athena:
 2245    '''
 2246
 2247    '''
 2248    __slots__ = [
 2249        'access_key',
 2250        'bind_interface',
 2251        'egress_filter',
 2252        'healthy',
 2253        'id',
 2254        'name',
 2255        'output',
 2256        'port_override',
 2257        'region',
 2258        'role_arn',
 2259        'role_external_id',
 2260        'secret_access_key',
 2261        'secret_store_id',
 2262        'tags',
 2263    ]
 2264
 2265    def __init__(
 2266        self,
 2267        access_key=None,
 2268        bind_interface=None,
 2269        egress_filter=None,
 2270        healthy=None,
 2271        id=None,
 2272        name=None,
 2273        output=None,
 2274        port_override=None,
 2275        region=None,
 2276        role_arn=None,
 2277        role_external_id=None,
 2278        secret_access_key=None,
 2279        secret_store_id=None,
 2280        tags=None,
 2281    ):
 2282        self.access_key = access_key if access_key is not None else ''
 2283        '''
 2284
 2285        '''
 2286        self.bind_interface = bind_interface if bind_interface is not None else ''
 2287        '''
 2288         Bind interface
 2289        '''
 2290        self.egress_filter = egress_filter if egress_filter is not None else ''
 2291        '''
 2292         A filter applied to the routing logic to pin datasource to nodes.
 2293        '''
 2294        self.healthy = healthy if healthy is not None else False
 2295        '''
 2296         True if the datasource is reachable and the credentials are valid.
 2297        '''
 2298        self.id = id if id is not None else ''
 2299        '''
 2300         Unique identifier of the Resource.
 2301        '''
 2302        self.name = name if name is not None else ''
 2303        '''
 2304         Unique human-readable name of the Resource.
 2305        '''
 2306        self.output = output if output is not None else ''
 2307        '''
 2308
 2309        '''
 2310        self.port_override = port_override if port_override is not None else 0
 2311        '''
 2312
 2313        '''
 2314        self.region = region if region is not None else ''
 2315        '''
 2316
 2317        '''
 2318        self.role_arn = role_arn if role_arn is not None else ''
 2319        '''
 2320
 2321        '''
 2322        self.role_external_id = role_external_id if role_external_id is not None else ''
 2323        '''
 2324
 2325        '''
 2326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2327        '''
 2328
 2329        '''
 2330        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2331        '''
 2332         ID of the secret store containing credentials for this resource, if any.
 2333        '''
 2334        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2335        '''
 2336         Tags is a map of key, value pairs.
 2337        '''
 2338
 2339    def __repr__(self):
 2340        return '<sdm.Athena ' + \
 2341            'access_key: ' + repr(self.access_key) + ' ' +\
 2342            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2343            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2344            'healthy: ' + repr(self.healthy) + ' ' +\
 2345            'id: ' + repr(self.id) + ' ' +\
 2346            'name: ' + repr(self.name) + ' ' +\
 2347            'output: ' + repr(self.output) + ' ' +\
 2348            'port_override: ' + repr(self.port_override) + ' ' +\
 2349            'region: ' + repr(self.region) + ' ' +\
 2350            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2351            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2352            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2353            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2354            'tags: ' + repr(self.tags) + ' ' +\
 2355            '>'
 2356
 2357    def to_dict(self):
 2358        return {
 2359            'access_key': self.access_key,
 2360            'bind_interface': self.bind_interface,
 2361            'egress_filter': self.egress_filter,
 2362            'healthy': self.healthy,
 2363            'id': self.id,
 2364            'name': self.name,
 2365            'output': self.output,
 2366            'port_override': self.port_override,
 2367            'region': self.region,
 2368            'role_arn': self.role_arn,
 2369            'role_external_id': self.role_external_id,
 2370            'secret_access_key': self.secret_access_key,
 2371            'secret_store_id': self.secret_store_id,
 2372            'tags': self.tags,
 2373        }
 2374
 2375    @classmethod
 2376    def from_dict(cls, d):
 2377        return cls(
 2378            access_key=d.get('access_key'),
 2379            bind_interface=d.get('bind_interface'),
 2380            egress_filter=d.get('egress_filter'),
 2381            healthy=d.get('healthy'),
 2382            id=d.get('id'),
 2383            name=d.get('name'),
 2384            output=d.get('output'),
 2385            port_override=d.get('port_override'),
 2386            region=d.get('region'),
 2387            role_arn=d.get('role_arn'),
 2388            role_external_id=d.get('role_external_id'),
 2389            secret_access_key=d.get('secret_access_key'),
 2390            secret_store_id=d.get('secret_store_id'),
 2391            tags=d.get('tags'),
 2392        )
 2393
 2394
 2395class AuroraMysql:
 2396    '''
 2397
 2398    '''
 2399    __slots__ = [
 2400        'bind_interface',
 2401        'database',
 2402        'egress_filter',
 2403        'healthy',
 2404        'hostname',
 2405        'id',
 2406        'name',
 2407        'password',
 2408        'port',
 2409        'port_override',
 2410        'secret_store_id',
 2411        'tags',
 2412        'username',
 2413    ]
 2414
 2415    def __init__(
 2416        self,
 2417        bind_interface=None,
 2418        database=None,
 2419        egress_filter=None,
 2420        healthy=None,
 2421        hostname=None,
 2422        id=None,
 2423        name=None,
 2424        password=None,
 2425        port=None,
 2426        port_override=None,
 2427        secret_store_id=None,
 2428        tags=None,
 2429        username=None,
 2430    ):
 2431        self.bind_interface = bind_interface if bind_interface is not None else ''
 2432        '''
 2433         Bind interface
 2434        '''
 2435        self.database = database if database is not None else ''
 2436        '''
 2437
 2438        '''
 2439        self.egress_filter = egress_filter if egress_filter is not None else ''
 2440        '''
 2441         A filter applied to the routing logic to pin datasource to nodes.
 2442        '''
 2443        self.healthy = healthy if healthy is not None else False
 2444        '''
 2445         True if the datasource is reachable and the credentials are valid.
 2446        '''
 2447        self.hostname = hostname if hostname is not None else ''
 2448        '''
 2449
 2450        '''
 2451        self.id = id if id is not None else ''
 2452        '''
 2453         Unique identifier of the Resource.
 2454        '''
 2455        self.name = name if name is not None else ''
 2456        '''
 2457         Unique human-readable name of the Resource.
 2458        '''
 2459        self.password = password if password is not None else ''
 2460        '''
 2461
 2462        '''
 2463        self.port = port if port is not None else 0
 2464        '''
 2465
 2466        '''
 2467        self.port_override = port_override if port_override is not None else 0
 2468        '''
 2469
 2470        '''
 2471        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2472        '''
 2473         ID of the secret store containing credentials for this resource, if any.
 2474        '''
 2475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2476        '''
 2477         Tags is a map of key, value pairs.
 2478        '''
 2479        self.username = username if username is not None else ''
 2480        '''
 2481
 2482        '''
 2483
 2484    def __repr__(self):
 2485        return '<sdm.AuroraMysql ' + \
 2486            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2487            'database: ' + repr(self.database) + ' ' +\
 2488            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2489            'healthy: ' + repr(self.healthy) + ' ' +\
 2490            'hostname: ' + repr(self.hostname) + ' ' +\
 2491            'id: ' + repr(self.id) + ' ' +\
 2492            'name: ' + repr(self.name) + ' ' +\
 2493            'password: ' + repr(self.password) + ' ' +\
 2494            'port: ' + repr(self.port) + ' ' +\
 2495            'port_override: ' + repr(self.port_override) + ' ' +\
 2496            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2497            'tags: ' + repr(self.tags) + ' ' +\
 2498            'username: ' + repr(self.username) + ' ' +\
 2499            '>'
 2500
 2501    def to_dict(self):
 2502        return {
 2503            'bind_interface': self.bind_interface,
 2504            'database': self.database,
 2505            'egress_filter': self.egress_filter,
 2506            'healthy': self.healthy,
 2507            'hostname': self.hostname,
 2508            'id': self.id,
 2509            'name': self.name,
 2510            'password': self.password,
 2511            'port': self.port,
 2512            'port_override': self.port_override,
 2513            'secret_store_id': self.secret_store_id,
 2514            'tags': self.tags,
 2515            'username': self.username,
 2516        }
 2517
 2518    @classmethod
 2519    def from_dict(cls, d):
 2520        return cls(
 2521            bind_interface=d.get('bind_interface'),
 2522            database=d.get('database'),
 2523            egress_filter=d.get('egress_filter'),
 2524            healthy=d.get('healthy'),
 2525            hostname=d.get('hostname'),
 2526            id=d.get('id'),
 2527            name=d.get('name'),
 2528            password=d.get('password'),
 2529            port=d.get('port'),
 2530            port_override=d.get('port_override'),
 2531            secret_store_id=d.get('secret_store_id'),
 2532            tags=d.get('tags'),
 2533            username=d.get('username'),
 2534        )
 2535
 2536
 2537class AuroraPostgres:
 2538    '''
 2539
 2540    '''
 2541    __slots__ = [
 2542        'bind_interface',
 2543        'database',
 2544        'egress_filter',
 2545        'healthy',
 2546        'hostname',
 2547        'id',
 2548        'name',
 2549        'override_database',
 2550        'password',
 2551        'port',
 2552        'port_override',
 2553        'secret_store_id',
 2554        'tags',
 2555        'username',
 2556    ]
 2557
 2558    def __init__(
 2559        self,
 2560        bind_interface=None,
 2561        database=None,
 2562        egress_filter=None,
 2563        healthy=None,
 2564        hostname=None,
 2565        id=None,
 2566        name=None,
 2567        override_database=None,
 2568        password=None,
 2569        port=None,
 2570        port_override=None,
 2571        secret_store_id=None,
 2572        tags=None,
 2573        username=None,
 2574    ):
 2575        self.bind_interface = bind_interface if bind_interface is not None else ''
 2576        '''
 2577         Bind interface
 2578        '''
 2579        self.database = database if database is not None else ''
 2580        '''
 2581
 2582        '''
 2583        self.egress_filter = egress_filter if egress_filter is not None else ''
 2584        '''
 2585         A filter applied to the routing logic to pin datasource to nodes.
 2586        '''
 2587        self.healthy = healthy if healthy is not None else False
 2588        '''
 2589         True if the datasource is reachable and the credentials are valid.
 2590        '''
 2591        self.hostname = hostname if hostname is not None else ''
 2592        '''
 2593
 2594        '''
 2595        self.id = id if id is not None else ''
 2596        '''
 2597         Unique identifier of the Resource.
 2598        '''
 2599        self.name = name if name is not None else ''
 2600        '''
 2601         Unique human-readable name of the Resource.
 2602        '''
 2603        self.override_database = override_database if override_database is not None else False
 2604        '''
 2605
 2606        '''
 2607        self.password = password if password is not None else ''
 2608        '''
 2609
 2610        '''
 2611        self.port = port if port is not None else 0
 2612        '''
 2613
 2614        '''
 2615        self.port_override = port_override if port_override is not None else 0
 2616        '''
 2617
 2618        '''
 2619        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2620        '''
 2621         ID of the secret store containing credentials for this resource, if any.
 2622        '''
 2623        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2624        '''
 2625         Tags is a map of key, value pairs.
 2626        '''
 2627        self.username = username if username is not None else ''
 2628        '''
 2629
 2630        '''
 2631
 2632    def __repr__(self):
 2633        return '<sdm.AuroraPostgres ' + \
 2634            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2635            'database: ' + repr(self.database) + ' ' +\
 2636            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2637            'healthy: ' + repr(self.healthy) + ' ' +\
 2638            'hostname: ' + repr(self.hostname) + ' ' +\
 2639            'id: ' + repr(self.id) + ' ' +\
 2640            'name: ' + repr(self.name) + ' ' +\
 2641            'override_database: ' + repr(self.override_database) + ' ' +\
 2642            'password: ' + repr(self.password) + ' ' +\
 2643            'port: ' + repr(self.port) + ' ' +\
 2644            'port_override: ' + repr(self.port_override) + ' ' +\
 2645            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2646            'tags: ' + repr(self.tags) + ' ' +\
 2647            'username: ' + repr(self.username) + ' ' +\
 2648            '>'
 2649
 2650    def to_dict(self):
 2651        return {
 2652            'bind_interface': self.bind_interface,
 2653            'database': self.database,
 2654            'egress_filter': self.egress_filter,
 2655            'healthy': self.healthy,
 2656            'hostname': self.hostname,
 2657            'id': self.id,
 2658            'name': self.name,
 2659            'override_database': self.override_database,
 2660            'password': self.password,
 2661            'port': self.port,
 2662            'port_override': self.port_override,
 2663            'secret_store_id': self.secret_store_id,
 2664            'tags': self.tags,
 2665            'username': self.username,
 2666        }
 2667
 2668    @classmethod
 2669    def from_dict(cls, d):
 2670        return cls(
 2671            bind_interface=d.get('bind_interface'),
 2672            database=d.get('database'),
 2673            egress_filter=d.get('egress_filter'),
 2674            healthy=d.get('healthy'),
 2675            hostname=d.get('hostname'),
 2676            id=d.get('id'),
 2677            name=d.get('name'),
 2678            override_database=d.get('override_database'),
 2679            password=d.get('password'),
 2680            port=d.get('port'),
 2681            port_override=d.get('port_override'),
 2682            secret_store_id=d.get('secret_store_id'),
 2683            tags=d.get('tags'),
 2684            username=d.get('username'),
 2685        )
 2686
 2687
 2688class Azure:
 2689    '''
 2690
 2691    '''
 2692    __slots__ = [
 2693        'app_id',
 2694        'bind_interface',
 2695        'egress_filter',
 2696        'healthy',
 2697        'id',
 2698        'name',
 2699        'password',
 2700        'secret_store_id',
 2701        'tags',
 2702        'tenant_id',
 2703    ]
 2704
 2705    def __init__(
 2706        self,
 2707        app_id=None,
 2708        bind_interface=None,
 2709        egress_filter=None,
 2710        healthy=None,
 2711        id=None,
 2712        name=None,
 2713        password=None,
 2714        secret_store_id=None,
 2715        tags=None,
 2716        tenant_id=None,
 2717    ):
 2718        self.app_id = app_id if app_id is not None else ''
 2719        '''
 2720
 2721        '''
 2722        self.bind_interface = bind_interface if bind_interface is not None else ''
 2723        '''
 2724         Bind interface
 2725        '''
 2726        self.egress_filter = egress_filter if egress_filter is not None else ''
 2727        '''
 2728         A filter applied to the routing logic to pin datasource to nodes.
 2729        '''
 2730        self.healthy = healthy if healthy is not None else False
 2731        '''
 2732         True if the datasource is reachable and the credentials are valid.
 2733        '''
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the Resource.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the Resource.
 2741        '''
 2742        self.password = password if password is not None else ''
 2743        '''
 2744
 2745        '''
 2746        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2747        '''
 2748         ID of the secret store containing credentials for this resource, if any.
 2749        '''
 2750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2751        '''
 2752         Tags is a map of key, value pairs.
 2753        '''
 2754        self.tenant_id = tenant_id if tenant_id is not None else ''
 2755        '''
 2756
 2757        '''
 2758
 2759    def __repr__(self):
 2760        return '<sdm.Azure ' + \
 2761            'app_id: ' + repr(self.app_id) + ' ' +\
 2762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2763            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2764            'healthy: ' + repr(self.healthy) + ' ' +\
 2765            'id: ' + repr(self.id) + ' ' +\
 2766            'name: ' + repr(self.name) + ' ' +\
 2767            'password: ' + repr(self.password) + ' ' +\
 2768            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2769            'tags: ' + repr(self.tags) + ' ' +\
 2770            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2771            '>'
 2772
 2773    def to_dict(self):
 2774        return {
 2775            'app_id': self.app_id,
 2776            'bind_interface': self.bind_interface,
 2777            'egress_filter': self.egress_filter,
 2778            'healthy': self.healthy,
 2779            'id': self.id,
 2780            'name': self.name,
 2781            'password': self.password,
 2782            'secret_store_id': self.secret_store_id,
 2783            'tags': self.tags,
 2784            'tenant_id': self.tenant_id,
 2785        }
 2786
 2787    @classmethod
 2788    def from_dict(cls, d):
 2789        return cls(
 2790            app_id=d.get('app_id'),
 2791            bind_interface=d.get('bind_interface'),
 2792            egress_filter=d.get('egress_filter'),
 2793            healthy=d.get('healthy'),
 2794            id=d.get('id'),
 2795            name=d.get('name'),
 2796            password=d.get('password'),
 2797            secret_store_id=d.get('secret_store_id'),
 2798            tags=d.get('tags'),
 2799            tenant_id=d.get('tenant_id'),
 2800        )
 2801
 2802
 2803class AzureCertificate:
 2804    '''
 2805
 2806    '''
 2807    __slots__ = [
 2808        'app_id',
 2809        'bind_interface',
 2810        'client_certificate',
 2811        'egress_filter',
 2812        'healthy',
 2813        'id',
 2814        'name',
 2815        'secret_store_id',
 2816        'tags',
 2817        'tenant_id',
 2818    ]
 2819
 2820    def __init__(
 2821        self,
 2822        app_id=None,
 2823        bind_interface=None,
 2824        client_certificate=None,
 2825        egress_filter=None,
 2826        healthy=None,
 2827        id=None,
 2828        name=None,
 2829        secret_store_id=None,
 2830        tags=None,
 2831        tenant_id=None,
 2832    ):
 2833        self.app_id = app_id if app_id is not None else ''
 2834        '''
 2835
 2836        '''
 2837        self.bind_interface = bind_interface if bind_interface is not None else ''
 2838        '''
 2839         Bind interface
 2840        '''
 2841        self.client_certificate = client_certificate if client_certificate is not None else ''
 2842        '''
 2843
 2844        '''
 2845        self.egress_filter = egress_filter if egress_filter is not None else ''
 2846        '''
 2847         A filter applied to the routing logic to pin datasource to nodes.
 2848        '''
 2849        self.healthy = healthy if healthy is not None else False
 2850        '''
 2851         True if the datasource is reachable and the credentials are valid.
 2852        '''
 2853        self.id = id if id is not None else ''
 2854        '''
 2855         Unique identifier of the Resource.
 2856        '''
 2857        self.name = name if name is not None else ''
 2858        '''
 2859         Unique human-readable name of the Resource.
 2860        '''
 2861        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2862        '''
 2863         ID of the secret store containing credentials for this resource, if any.
 2864        '''
 2865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2866        '''
 2867         Tags is a map of key, value pairs.
 2868        '''
 2869        self.tenant_id = tenant_id if tenant_id is not None else ''
 2870        '''
 2871
 2872        '''
 2873
 2874    def __repr__(self):
 2875        return '<sdm.AzureCertificate ' + \
 2876            'app_id: ' + repr(self.app_id) + ' ' +\
 2877            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2878            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2879            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2880            'healthy: ' + repr(self.healthy) + ' ' +\
 2881            'id: ' + repr(self.id) + ' ' +\
 2882            'name: ' + repr(self.name) + ' ' +\
 2883            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2884            'tags: ' + repr(self.tags) + ' ' +\
 2885            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2886            '>'
 2887
 2888    def to_dict(self):
 2889        return {
 2890            'app_id': self.app_id,
 2891            'bind_interface': self.bind_interface,
 2892            'client_certificate': self.client_certificate,
 2893            'egress_filter': self.egress_filter,
 2894            'healthy': self.healthy,
 2895            'id': self.id,
 2896            'name': self.name,
 2897            'secret_store_id': self.secret_store_id,
 2898            'tags': self.tags,
 2899            'tenant_id': self.tenant_id,
 2900        }
 2901
 2902    @classmethod
 2903    def from_dict(cls, d):
 2904        return cls(
 2905            app_id=d.get('app_id'),
 2906            bind_interface=d.get('bind_interface'),
 2907            client_certificate=d.get('client_certificate'),
 2908            egress_filter=d.get('egress_filter'),
 2909            healthy=d.get('healthy'),
 2910            id=d.get('id'),
 2911            name=d.get('name'),
 2912            secret_store_id=d.get('secret_store_id'),
 2913            tags=d.get('tags'),
 2914            tenant_id=d.get('tenant_id'),
 2915        )
 2916
 2917
 2918class AzurePostgres:
 2919    '''
 2920
 2921    '''
 2922    __slots__ = [
 2923        'bind_interface',
 2924        'database',
 2925        'egress_filter',
 2926        'healthy',
 2927        'hostname',
 2928        'id',
 2929        'name',
 2930        'override_database',
 2931        'password',
 2932        'port',
 2933        'port_override',
 2934        'secret_store_id',
 2935        'tags',
 2936        'username',
 2937    ]
 2938
 2939    def __init__(
 2940        self,
 2941        bind_interface=None,
 2942        database=None,
 2943        egress_filter=None,
 2944        healthy=None,
 2945        hostname=None,
 2946        id=None,
 2947        name=None,
 2948        override_database=None,
 2949        password=None,
 2950        port=None,
 2951        port_override=None,
 2952        secret_store_id=None,
 2953        tags=None,
 2954        username=None,
 2955    ):
 2956        self.bind_interface = bind_interface if bind_interface is not None else ''
 2957        '''
 2958         Bind interface
 2959        '''
 2960        self.database = database if database is not None else ''
 2961        '''
 2962
 2963        '''
 2964        self.egress_filter = egress_filter if egress_filter is not None else ''
 2965        '''
 2966         A filter applied to the routing logic to pin datasource to nodes.
 2967        '''
 2968        self.healthy = healthy if healthy is not None else False
 2969        '''
 2970         True if the datasource is reachable and the credentials are valid.
 2971        '''
 2972        self.hostname = hostname if hostname is not None else ''
 2973        '''
 2974
 2975        '''
 2976        self.id = id if id is not None else ''
 2977        '''
 2978         Unique identifier of the Resource.
 2979        '''
 2980        self.name = name if name is not None else ''
 2981        '''
 2982         Unique human-readable name of the Resource.
 2983        '''
 2984        self.override_database = override_database if override_database is not None else False
 2985        '''
 2986
 2987        '''
 2988        self.password = password if password is not None else ''
 2989        '''
 2990
 2991        '''
 2992        self.port = port if port is not None else 0
 2993        '''
 2994
 2995        '''
 2996        self.port_override = port_override if port_override is not None else 0
 2997        '''
 2998
 2999        '''
 3000        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3001        '''
 3002         ID of the secret store containing credentials for this resource, if any.
 3003        '''
 3004        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3005        '''
 3006         Tags is a map of key, value pairs.
 3007        '''
 3008        self.username = username if username is not None else ''
 3009        '''
 3010
 3011        '''
 3012
 3013    def __repr__(self):
 3014        return '<sdm.AzurePostgres ' + \
 3015            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3016            'database: ' + repr(self.database) + ' ' +\
 3017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3018            'healthy: ' + repr(self.healthy) + ' ' +\
 3019            'hostname: ' + repr(self.hostname) + ' ' +\
 3020            'id: ' + repr(self.id) + ' ' +\
 3021            'name: ' + repr(self.name) + ' ' +\
 3022            'override_database: ' + repr(self.override_database) + ' ' +\
 3023            'password: ' + repr(self.password) + ' ' +\
 3024            'port: ' + repr(self.port) + ' ' +\
 3025            'port_override: ' + repr(self.port_override) + ' ' +\
 3026            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3027            'tags: ' + repr(self.tags) + ' ' +\
 3028            'username: ' + repr(self.username) + ' ' +\
 3029            '>'
 3030
 3031    def to_dict(self):
 3032        return {
 3033            'bind_interface': self.bind_interface,
 3034            'database': self.database,
 3035            'egress_filter': self.egress_filter,
 3036            'healthy': self.healthy,
 3037            'hostname': self.hostname,
 3038            'id': self.id,
 3039            'name': self.name,
 3040            'override_database': self.override_database,
 3041            'password': self.password,
 3042            'port': self.port,
 3043            'port_override': self.port_override,
 3044            'secret_store_id': self.secret_store_id,
 3045            'tags': self.tags,
 3046            'username': self.username,
 3047        }
 3048
 3049    @classmethod
 3050    def from_dict(cls, d):
 3051        return cls(
 3052            bind_interface=d.get('bind_interface'),
 3053            database=d.get('database'),
 3054            egress_filter=d.get('egress_filter'),
 3055            healthy=d.get('healthy'),
 3056            hostname=d.get('hostname'),
 3057            id=d.get('id'),
 3058            name=d.get('name'),
 3059            override_database=d.get('override_database'),
 3060            password=d.get('password'),
 3061            port=d.get('port'),
 3062            port_override=d.get('port_override'),
 3063            secret_store_id=d.get('secret_store_id'),
 3064            tags=d.get('tags'),
 3065            username=d.get('username'),
 3066        )
 3067
 3068
 3069class AzureStore:
 3070    '''
 3071
 3072    '''
 3073    __slots__ = [
 3074        'id',
 3075        'name',
 3076        'tags',
 3077        'vault_uri',
 3078    ]
 3079
 3080    def __init__(
 3081        self,
 3082        id=None,
 3083        name=None,
 3084        tags=None,
 3085        vault_uri=None,
 3086    ):
 3087        self.id = id if id is not None else ''
 3088        '''
 3089         Unique identifier of the SecretStore.
 3090        '''
 3091        self.name = name if name is not None else ''
 3092        '''
 3093         Unique human-readable name of the SecretStore.
 3094        '''
 3095        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3096        '''
 3097         Tags is a map of key, value pairs.
 3098        '''
 3099        self.vault_uri = vault_uri if vault_uri is not None else ''
 3100        '''
 3101
 3102        '''
 3103
 3104    def __repr__(self):
 3105        return '<sdm.AzureStore ' + \
 3106            'id: ' + repr(self.id) + ' ' +\
 3107            'name: ' + repr(self.name) + ' ' +\
 3108            'tags: ' + repr(self.tags) + ' ' +\
 3109            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3110            '>'
 3111
 3112    def to_dict(self):
 3113        return {
 3114            'id': self.id,
 3115            'name': self.name,
 3116            'tags': self.tags,
 3117            'vault_uri': self.vault_uri,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            id=d.get('id'),
 3124            name=d.get('name'),
 3125            tags=d.get('tags'),
 3126            vault_uri=d.get('vault_uri'),
 3127        )
 3128
 3129
 3130class BigQuery:
 3131    '''
 3132
 3133    '''
 3134    __slots__ = [
 3135        'bind_interface',
 3136        'egress_filter',
 3137        'endpoint',
 3138        'healthy',
 3139        'id',
 3140        'name',
 3141        'port_override',
 3142        'private_key',
 3143        'project',
 3144        'secret_store_id',
 3145        'tags',
 3146        'username',
 3147    ]
 3148
 3149    def __init__(
 3150        self,
 3151        bind_interface=None,
 3152        egress_filter=None,
 3153        endpoint=None,
 3154        healthy=None,
 3155        id=None,
 3156        name=None,
 3157        port_override=None,
 3158        private_key=None,
 3159        project=None,
 3160        secret_store_id=None,
 3161        tags=None,
 3162        username=None,
 3163    ):
 3164        self.bind_interface = bind_interface if bind_interface is not None else ''
 3165        '''
 3166         Bind interface
 3167        '''
 3168        self.egress_filter = egress_filter if egress_filter is not None else ''
 3169        '''
 3170         A filter applied to the routing logic to pin datasource to nodes.
 3171        '''
 3172        self.endpoint = endpoint if endpoint is not None else ''
 3173        '''
 3174
 3175        '''
 3176        self.healthy = healthy if healthy is not None else False
 3177        '''
 3178         True if the datasource is reachable and the credentials are valid.
 3179        '''
 3180        self.id = id if id is not None else ''
 3181        '''
 3182         Unique identifier of the Resource.
 3183        '''
 3184        self.name = name if name is not None else ''
 3185        '''
 3186         Unique human-readable name of the Resource.
 3187        '''
 3188        self.port_override = port_override if port_override is not None else 0
 3189        '''
 3190
 3191        '''
 3192        self.private_key = private_key if private_key is not None else ''
 3193        '''
 3194
 3195        '''
 3196        self.project = project if project is not None else ''
 3197        '''
 3198
 3199        '''
 3200        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3201        '''
 3202         ID of the secret store containing credentials for this resource, if any.
 3203        '''
 3204        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3205        '''
 3206         Tags is a map of key, value pairs.
 3207        '''
 3208        self.username = username if username is not None else ''
 3209        '''
 3210
 3211        '''
 3212
 3213    def __repr__(self):
 3214        return '<sdm.BigQuery ' + \
 3215            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3216            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3217            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3218            'healthy: ' + repr(self.healthy) + ' ' +\
 3219            'id: ' + repr(self.id) + ' ' +\
 3220            'name: ' + repr(self.name) + ' ' +\
 3221            'port_override: ' + repr(self.port_override) + ' ' +\
 3222            'private_key: ' + repr(self.private_key) + ' ' +\
 3223            'project: ' + repr(self.project) + ' ' +\
 3224            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3225            'tags: ' + repr(self.tags) + ' ' +\
 3226            'username: ' + repr(self.username) + ' ' +\
 3227            '>'
 3228
 3229    def to_dict(self):
 3230        return {
 3231            'bind_interface': self.bind_interface,
 3232            'egress_filter': self.egress_filter,
 3233            'endpoint': self.endpoint,
 3234            'healthy': self.healthy,
 3235            'id': self.id,
 3236            'name': self.name,
 3237            'port_override': self.port_override,
 3238            'private_key': self.private_key,
 3239            'project': self.project,
 3240            'secret_store_id': self.secret_store_id,
 3241            'tags': self.tags,
 3242            'username': self.username,
 3243        }
 3244
 3245    @classmethod
 3246    def from_dict(cls, d):
 3247        return cls(
 3248            bind_interface=d.get('bind_interface'),
 3249            egress_filter=d.get('egress_filter'),
 3250            endpoint=d.get('endpoint'),
 3251            healthy=d.get('healthy'),
 3252            id=d.get('id'),
 3253            name=d.get('name'),
 3254            port_override=d.get('port_override'),
 3255            private_key=d.get('private_key'),
 3256            project=d.get('project'),
 3257            secret_store_id=d.get('secret_store_id'),
 3258            tags=d.get('tags'),
 3259            username=d.get('username'),
 3260        )
 3261
 3262
 3263class Cassandra:
 3264    '''
 3265
 3266    '''
 3267    __slots__ = [
 3268        'bind_interface',
 3269        'egress_filter',
 3270        'healthy',
 3271        'hostname',
 3272        'id',
 3273        'name',
 3274        'password',
 3275        'port',
 3276        'port_override',
 3277        'secret_store_id',
 3278        'tags',
 3279        'tls_required',
 3280        'username',
 3281    ]
 3282
 3283    def __init__(
 3284        self,
 3285        bind_interface=None,
 3286        egress_filter=None,
 3287        healthy=None,
 3288        hostname=None,
 3289        id=None,
 3290        name=None,
 3291        password=None,
 3292        port=None,
 3293        port_override=None,
 3294        secret_store_id=None,
 3295        tags=None,
 3296        tls_required=None,
 3297        username=None,
 3298    ):
 3299        self.bind_interface = bind_interface if bind_interface is not None else ''
 3300        '''
 3301         Bind interface
 3302        '''
 3303        self.egress_filter = egress_filter if egress_filter is not None else ''
 3304        '''
 3305         A filter applied to the routing logic to pin datasource to nodes.
 3306        '''
 3307        self.healthy = healthy if healthy is not None else False
 3308        '''
 3309         True if the datasource is reachable and the credentials are valid.
 3310        '''
 3311        self.hostname = hostname if hostname is not None else ''
 3312        '''
 3313
 3314        '''
 3315        self.id = id if id is not None else ''
 3316        '''
 3317         Unique identifier of the Resource.
 3318        '''
 3319        self.name = name if name is not None else ''
 3320        '''
 3321         Unique human-readable name of the Resource.
 3322        '''
 3323        self.password = password if password is not None else ''
 3324        '''
 3325
 3326        '''
 3327        self.port = port if port is not None else 0
 3328        '''
 3329
 3330        '''
 3331        self.port_override = port_override if port_override is not None else 0
 3332        '''
 3333
 3334        '''
 3335        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3336        '''
 3337         ID of the secret store containing credentials for this resource, if any.
 3338        '''
 3339        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3340        '''
 3341         Tags is a map of key, value pairs.
 3342        '''
 3343        self.tls_required = tls_required if tls_required is not None else False
 3344        '''
 3345
 3346        '''
 3347        self.username = username if username is not None else ''
 3348        '''
 3349
 3350        '''
 3351
 3352    def __repr__(self):
 3353        return '<sdm.Cassandra ' + \
 3354            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3355            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3356            'healthy: ' + repr(self.healthy) + ' ' +\
 3357            'hostname: ' + repr(self.hostname) + ' ' +\
 3358            'id: ' + repr(self.id) + ' ' +\
 3359            'name: ' + repr(self.name) + ' ' +\
 3360            'password: ' + repr(self.password) + ' ' +\
 3361            'port: ' + repr(self.port) + ' ' +\
 3362            'port_override: ' + repr(self.port_override) + ' ' +\
 3363            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3364            'tags: ' + repr(self.tags) + ' ' +\
 3365            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3366            'username: ' + repr(self.username) + ' ' +\
 3367            '>'
 3368
 3369    def to_dict(self):
 3370        return {
 3371            'bind_interface': self.bind_interface,
 3372            'egress_filter': self.egress_filter,
 3373            'healthy': self.healthy,
 3374            'hostname': self.hostname,
 3375            'id': self.id,
 3376            'name': self.name,
 3377            'password': self.password,
 3378            'port': self.port,
 3379            'port_override': self.port_override,
 3380            'secret_store_id': self.secret_store_id,
 3381            'tags': self.tags,
 3382            'tls_required': self.tls_required,
 3383            'username': self.username,
 3384        }
 3385
 3386    @classmethod
 3387    def from_dict(cls, d):
 3388        return cls(
 3389            bind_interface=d.get('bind_interface'),
 3390            egress_filter=d.get('egress_filter'),
 3391            healthy=d.get('healthy'),
 3392            hostname=d.get('hostname'),
 3393            id=d.get('id'),
 3394            name=d.get('name'),
 3395            password=d.get('password'),
 3396            port=d.get('port'),
 3397            port_override=d.get('port_override'),
 3398            secret_store_id=d.get('secret_store_id'),
 3399            tags=d.get('tags'),
 3400            tls_required=d.get('tls_required'),
 3401            username=d.get('username'),
 3402        )
 3403
 3404
 3405class Citus:
 3406    '''
 3407
 3408    '''
 3409    __slots__ = [
 3410        'bind_interface',
 3411        'database',
 3412        'egress_filter',
 3413        'healthy',
 3414        'hostname',
 3415        'id',
 3416        'name',
 3417        'override_database',
 3418        'password',
 3419        'port',
 3420        'port_override',
 3421        'secret_store_id',
 3422        'tags',
 3423        'username',
 3424    ]
 3425
 3426    def __init__(
 3427        self,
 3428        bind_interface=None,
 3429        database=None,
 3430        egress_filter=None,
 3431        healthy=None,
 3432        hostname=None,
 3433        id=None,
 3434        name=None,
 3435        override_database=None,
 3436        password=None,
 3437        port=None,
 3438        port_override=None,
 3439        secret_store_id=None,
 3440        tags=None,
 3441        username=None,
 3442    ):
 3443        self.bind_interface = bind_interface if bind_interface is not None else ''
 3444        '''
 3445         Bind interface
 3446        '''
 3447        self.database = database if database is not None else ''
 3448        '''
 3449
 3450        '''
 3451        self.egress_filter = egress_filter if egress_filter is not None else ''
 3452        '''
 3453         A filter applied to the routing logic to pin datasource to nodes.
 3454        '''
 3455        self.healthy = healthy if healthy is not None else False
 3456        '''
 3457         True if the datasource is reachable and the credentials are valid.
 3458        '''
 3459        self.hostname = hostname if hostname is not None else ''
 3460        '''
 3461
 3462        '''
 3463        self.id = id if id is not None else ''
 3464        '''
 3465         Unique identifier of the Resource.
 3466        '''
 3467        self.name = name if name is not None else ''
 3468        '''
 3469         Unique human-readable name of the Resource.
 3470        '''
 3471        self.override_database = override_database if override_database is not None else False
 3472        '''
 3473
 3474        '''
 3475        self.password = password if password is not None else ''
 3476        '''
 3477
 3478        '''
 3479        self.port = port if port is not None else 0
 3480        '''
 3481
 3482        '''
 3483        self.port_override = port_override if port_override is not None else 0
 3484        '''
 3485
 3486        '''
 3487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3488        '''
 3489         ID of the secret store containing credentials for this resource, if any.
 3490        '''
 3491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3492        '''
 3493         Tags is a map of key, value pairs.
 3494        '''
 3495        self.username = username if username is not None else ''
 3496        '''
 3497
 3498        '''
 3499
 3500    def __repr__(self):
 3501        return '<sdm.Citus ' + \
 3502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3503            'database: ' + repr(self.database) + ' ' +\
 3504            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3505            'healthy: ' + repr(self.healthy) + ' ' +\
 3506            'hostname: ' + repr(self.hostname) + ' ' +\
 3507            'id: ' + repr(self.id) + ' ' +\
 3508            'name: ' + repr(self.name) + ' ' +\
 3509            'override_database: ' + repr(self.override_database) + ' ' +\
 3510            'password: ' + repr(self.password) + ' ' +\
 3511            'port: ' + repr(self.port) + ' ' +\
 3512            'port_override: ' + repr(self.port_override) + ' ' +\
 3513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3514            'tags: ' + repr(self.tags) + ' ' +\
 3515            'username: ' + repr(self.username) + ' ' +\
 3516            '>'
 3517
 3518    def to_dict(self):
 3519        return {
 3520            'bind_interface': self.bind_interface,
 3521            'database': self.database,
 3522            'egress_filter': self.egress_filter,
 3523            'healthy': self.healthy,
 3524            'hostname': self.hostname,
 3525            'id': self.id,
 3526            'name': self.name,
 3527            'override_database': self.override_database,
 3528            'password': self.password,
 3529            'port': self.port,
 3530            'port_override': self.port_override,
 3531            'secret_store_id': self.secret_store_id,
 3532            'tags': self.tags,
 3533            'username': self.username,
 3534        }
 3535
 3536    @classmethod
 3537    def from_dict(cls, d):
 3538        return cls(
 3539            bind_interface=d.get('bind_interface'),
 3540            database=d.get('database'),
 3541            egress_filter=d.get('egress_filter'),
 3542            healthy=d.get('healthy'),
 3543            hostname=d.get('hostname'),
 3544            id=d.get('id'),
 3545            name=d.get('name'),
 3546            override_database=d.get('override_database'),
 3547            password=d.get('password'),
 3548            port=d.get('port'),
 3549            port_override=d.get('port_override'),
 3550            secret_store_id=d.get('secret_store_id'),
 3551            tags=d.get('tags'),
 3552            username=d.get('username'),
 3553        )
 3554
 3555
 3556class Clustrix:
 3557    '''
 3558
 3559    '''
 3560    __slots__ = [
 3561        'bind_interface',
 3562        'database',
 3563        'egress_filter',
 3564        'healthy',
 3565        'hostname',
 3566        'id',
 3567        'name',
 3568        'password',
 3569        'port',
 3570        'port_override',
 3571        'secret_store_id',
 3572        'tags',
 3573        'username',
 3574    ]
 3575
 3576    def __init__(
 3577        self,
 3578        bind_interface=None,
 3579        database=None,
 3580        egress_filter=None,
 3581        healthy=None,
 3582        hostname=None,
 3583        id=None,
 3584        name=None,
 3585        password=None,
 3586        port=None,
 3587        port_override=None,
 3588        secret_store_id=None,
 3589        tags=None,
 3590        username=None,
 3591    ):
 3592        self.bind_interface = bind_interface if bind_interface is not None else ''
 3593        '''
 3594         Bind interface
 3595        '''
 3596        self.database = database if database is not None else ''
 3597        '''
 3598
 3599        '''
 3600        self.egress_filter = egress_filter if egress_filter is not None else ''
 3601        '''
 3602         A filter applied to the routing logic to pin datasource to nodes.
 3603        '''
 3604        self.healthy = healthy if healthy is not None else False
 3605        '''
 3606         True if the datasource is reachable and the credentials are valid.
 3607        '''
 3608        self.hostname = hostname if hostname is not None else ''
 3609        '''
 3610
 3611        '''
 3612        self.id = id if id is not None else ''
 3613        '''
 3614         Unique identifier of the Resource.
 3615        '''
 3616        self.name = name if name is not None else ''
 3617        '''
 3618         Unique human-readable name of the Resource.
 3619        '''
 3620        self.password = password if password is not None else ''
 3621        '''
 3622
 3623        '''
 3624        self.port = port if port is not None else 0
 3625        '''
 3626
 3627        '''
 3628        self.port_override = port_override if port_override is not None else 0
 3629        '''
 3630
 3631        '''
 3632        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3633        '''
 3634         ID of the secret store containing credentials for this resource, if any.
 3635        '''
 3636        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3637        '''
 3638         Tags is a map of key, value pairs.
 3639        '''
 3640        self.username = username if username is not None else ''
 3641        '''
 3642
 3643        '''
 3644
 3645    def __repr__(self):
 3646        return '<sdm.Clustrix ' + \
 3647            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3648            'database: ' + repr(self.database) + ' ' +\
 3649            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3650            'healthy: ' + repr(self.healthy) + ' ' +\
 3651            'hostname: ' + repr(self.hostname) + ' ' +\
 3652            'id: ' + repr(self.id) + ' ' +\
 3653            'name: ' + repr(self.name) + ' ' +\
 3654            'password: ' + repr(self.password) + ' ' +\
 3655            'port: ' + repr(self.port) + ' ' +\
 3656            'port_override: ' + repr(self.port_override) + ' ' +\
 3657            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3658            'tags: ' + repr(self.tags) + ' ' +\
 3659            'username: ' + repr(self.username) + ' ' +\
 3660            '>'
 3661
 3662    def to_dict(self):
 3663        return {
 3664            'bind_interface': self.bind_interface,
 3665            'database': self.database,
 3666            'egress_filter': self.egress_filter,
 3667            'healthy': self.healthy,
 3668            'hostname': self.hostname,
 3669            'id': self.id,
 3670            'name': self.name,
 3671            'password': self.password,
 3672            'port': self.port,
 3673            'port_override': self.port_override,
 3674            'secret_store_id': self.secret_store_id,
 3675            'tags': self.tags,
 3676            'username': self.username,
 3677        }
 3678
 3679    @classmethod
 3680    def from_dict(cls, d):
 3681        return cls(
 3682            bind_interface=d.get('bind_interface'),
 3683            database=d.get('database'),
 3684            egress_filter=d.get('egress_filter'),
 3685            healthy=d.get('healthy'),
 3686            hostname=d.get('hostname'),
 3687            id=d.get('id'),
 3688            name=d.get('name'),
 3689            password=d.get('password'),
 3690            port=d.get('port'),
 3691            port_override=d.get('port_override'),
 3692            secret_store_id=d.get('secret_store_id'),
 3693            tags=d.get('tags'),
 3694            username=d.get('username'),
 3695        )
 3696
 3697
 3698class Cockroach:
 3699    '''
 3700
 3701    '''
 3702    __slots__ = [
 3703        'bind_interface',
 3704        'database',
 3705        'egress_filter',
 3706        'healthy',
 3707        'hostname',
 3708        'id',
 3709        'name',
 3710        'override_database',
 3711        'password',
 3712        'port',
 3713        'port_override',
 3714        'secret_store_id',
 3715        'tags',
 3716        'username',
 3717    ]
 3718
 3719    def __init__(
 3720        self,
 3721        bind_interface=None,
 3722        database=None,
 3723        egress_filter=None,
 3724        healthy=None,
 3725        hostname=None,
 3726        id=None,
 3727        name=None,
 3728        override_database=None,
 3729        password=None,
 3730        port=None,
 3731        port_override=None,
 3732        secret_store_id=None,
 3733        tags=None,
 3734        username=None,
 3735    ):
 3736        self.bind_interface = bind_interface if bind_interface is not None else ''
 3737        '''
 3738         Bind interface
 3739        '''
 3740        self.database = database if database is not None else ''
 3741        '''
 3742
 3743        '''
 3744        self.egress_filter = egress_filter if egress_filter is not None else ''
 3745        '''
 3746         A filter applied to the routing logic to pin datasource to nodes.
 3747        '''
 3748        self.healthy = healthy if healthy is not None else False
 3749        '''
 3750         True if the datasource is reachable and the credentials are valid.
 3751        '''
 3752        self.hostname = hostname if hostname is not None else ''
 3753        '''
 3754
 3755        '''
 3756        self.id = id if id is not None else ''
 3757        '''
 3758         Unique identifier of the Resource.
 3759        '''
 3760        self.name = name if name is not None else ''
 3761        '''
 3762         Unique human-readable name of the Resource.
 3763        '''
 3764        self.override_database = override_database if override_database is not None else False
 3765        '''
 3766
 3767        '''
 3768        self.password = password if password is not None else ''
 3769        '''
 3770
 3771        '''
 3772        self.port = port if port is not None else 0
 3773        '''
 3774
 3775        '''
 3776        self.port_override = port_override if port_override is not None else 0
 3777        '''
 3778
 3779        '''
 3780        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3781        '''
 3782         ID of the secret store containing credentials for this resource, if any.
 3783        '''
 3784        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3785        '''
 3786         Tags is a map of key, value pairs.
 3787        '''
 3788        self.username = username if username is not None else ''
 3789        '''
 3790
 3791        '''
 3792
 3793    def __repr__(self):
 3794        return '<sdm.Cockroach ' + \
 3795            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3796            'database: ' + repr(self.database) + ' ' +\
 3797            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3798            'healthy: ' + repr(self.healthy) + ' ' +\
 3799            'hostname: ' + repr(self.hostname) + ' ' +\
 3800            'id: ' + repr(self.id) + ' ' +\
 3801            'name: ' + repr(self.name) + ' ' +\
 3802            'override_database: ' + repr(self.override_database) + ' ' +\
 3803            'password: ' + repr(self.password) + ' ' +\
 3804            'port: ' + repr(self.port) + ' ' +\
 3805            'port_override: ' + repr(self.port_override) + ' ' +\
 3806            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3807            'tags: ' + repr(self.tags) + ' ' +\
 3808            'username: ' + repr(self.username) + ' ' +\
 3809            '>'
 3810
 3811    def to_dict(self):
 3812        return {
 3813            'bind_interface': self.bind_interface,
 3814            'database': self.database,
 3815            'egress_filter': self.egress_filter,
 3816            'healthy': self.healthy,
 3817            'hostname': self.hostname,
 3818            'id': self.id,
 3819            'name': self.name,
 3820            'override_database': self.override_database,
 3821            'password': self.password,
 3822            'port': self.port,
 3823            'port_override': self.port_override,
 3824            'secret_store_id': self.secret_store_id,
 3825            'tags': self.tags,
 3826            'username': self.username,
 3827        }
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls(
 3832            bind_interface=d.get('bind_interface'),
 3833            database=d.get('database'),
 3834            egress_filter=d.get('egress_filter'),
 3835            healthy=d.get('healthy'),
 3836            hostname=d.get('hostname'),
 3837            id=d.get('id'),
 3838            name=d.get('name'),
 3839            override_database=d.get('override_database'),
 3840            password=d.get('password'),
 3841            port=d.get('port'),
 3842            port_override=d.get('port_override'),
 3843            secret_store_id=d.get('secret_store_id'),
 3844            tags=d.get('tags'),
 3845            username=d.get('username'),
 3846        )
 3847
 3848
 3849class ControlPanelGetSSHCAPublicKeyResponse:
 3850    '''
 3851     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3852     organization's SSH Certificate Authority public key.
 3853    '''
 3854    __slots__ = [
 3855        'meta',
 3856        'public_key',
 3857        'rate_limit',
 3858    ]
 3859
 3860    def __init__(
 3861        self,
 3862        meta=None,
 3863        public_key=None,
 3864        rate_limit=None,
 3865    ):
 3866        self.meta = meta if meta is not None else None
 3867        '''
 3868         Reserved for future use.
 3869        '''
 3870        self.public_key = public_key if public_key is not None else ''
 3871        '''
 3872         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3873         key format.
 3874        '''
 3875        self.rate_limit = rate_limit if rate_limit is not None else None
 3876        '''
 3877         Rate limit information.
 3878        '''
 3879
 3880    def __repr__(self):
 3881        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3882            'meta: ' + repr(self.meta) + ' ' +\
 3883            'public_key: ' + repr(self.public_key) + ' ' +\
 3884            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3885            '>'
 3886
 3887    def to_dict(self):
 3888        return {
 3889            'meta': self.meta,
 3890            'public_key': self.public_key,
 3891            'rate_limit': self.rate_limit,
 3892        }
 3893
 3894    @classmethod
 3895    def from_dict(cls, d):
 3896        return cls(
 3897            meta=d.get('meta'),
 3898            public_key=d.get('public_key'),
 3899            rate_limit=d.get('rate_limit'),
 3900        )
 3901
 3902
 3903class ControlPanelVerifyJWTResponse:
 3904    '''
 3905     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3906    '''
 3907    __slots__ = [
 3908        'meta',
 3909        'rate_limit',
 3910        'valid',
 3911    ]
 3912
 3913    def __init__(
 3914        self,
 3915        meta=None,
 3916        rate_limit=None,
 3917        valid=None,
 3918    ):
 3919        self.meta = meta if meta is not None else None
 3920        '''
 3921         Reserved for future use.
 3922        '''
 3923        self.rate_limit = rate_limit if rate_limit is not None else None
 3924        '''
 3925         Rate limit information.
 3926        '''
 3927        self.valid = valid if valid is not None else False
 3928        '''
 3929         Reports if the given token is valid.
 3930        '''
 3931
 3932    def __repr__(self):
 3933        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3934            'meta: ' + repr(self.meta) + ' ' +\
 3935            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3936            'valid: ' + repr(self.valid) + ' ' +\
 3937            '>'
 3938
 3939    def to_dict(self):
 3940        return {
 3941            'meta': self.meta,
 3942            'rate_limit': self.rate_limit,
 3943            'valid': self.valid,
 3944        }
 3945
 3946    @classmethod
 3947    def from_dict(cls, d):
 3948        return cls(
 3949            meta=d.get('meta'),
 3950            rate_limit=d.get('rate_limit'),
 3951            valid=d.get('valid'),
 3952        )
 3953
 3954
 3955class CreateResponseMetadata:
 3956    '''
 3957     CreateResponseMetadata is reserved for future use.
 3958    '''
 3959    __slots__ = []
 3960
 3961    def __init__(self, ):
 3962        pass
 3963
 3964    def __repr__(self):
 3965        return '<sdm.CreateResponseMetadata ' + \
 3966            '>'
 3967
 3968    def to_dict(self):
 3969        return {}
 3970
 3971    @classmethod
 3972    def from_dict(cls, d):
 3973        return cls()
 3974
 3975
 3976class DB2I:
 3977    '''
 3978
 3979    '''
 3980    __slots__ = [
 3981        'bind_interface',
 3982        'egress_filter',
 3983        'healthy',
 3984        'hostname',
 3985        'id',
 3986        'name',
 3987        'password',
 3988        'port',
 3989        'port_override',
 3990        'secret_store_id',
 3991        'tags',
 3992        'tls_required',
 3993        'username',
 3994    ]
 3995
 3996    def __init__(
 3997        self,
 3998        bind_interface=None,
 3999        egress_filter=None,
 4000        healthy=None,
 4001        hostname=None,
 4002        id=None,
 4003        name=None,
 4004        password=None,
 4005        port=None,
 4006        port_override=None,
 4007        secret_store_id=None,
 4008        tags=None,
 4009        tls_required=None,
 4010        username=None,
 4011    ):
 4012        self.bind_interface = bind_interface if bind_interface is not None else ''
 4013        '''
 4014         Bind interface
 4015        '''
 4016        self.egress_filter = egress_filter if egress_filter is not None else ''
 4017        '''
 4018         A filter applied to the routing logic to pin datasource to nodes.
 4019        '''
 4020        self.healthy = healthy if healthy is not None else False
 4021        '''
 4022         True if the datasource is reachable and the credentials are valid.
 4023        '''
 4024        self.hostname = hostname if hostname is not None else ''
 4025        '''
 4026
 4027        '''
 4028        self.id = id if id is not None else ''
 4029        '''
 4030         Unique identifier of the Resource.
 4031        '''
 4032        self.name = name if name is not None else ''
 4033        '''
 4034         Unique human-readable name of the Resource.
 4035        '''
 4036        self.password = password if password is not None else ''
 4037        '''
 4038
 4039        '''
 4040        self.port = port if port is not None else 0
 4041        '''
 4042
 4043        '''
 4044        self.port_override = port_override if port_override is not None else 0
 4045        '''
 4046
 4047        '''
 4048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4049        '''
 4050         ID of the secret store containing credentials for this resource, if any.
 4051        '''
 4052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4053        '''
 4054         Tags is a map of key, value pairs.
 4055        '''
 4056        self.tls_required = tls_required if tls_required is not None else False
 4057        '''
 4058
 4059        '''
 4060        self.username = username if username is not None else ''
 4061        '''
 4062
 4063        '''
 4064
 4065    def __repr__(self):
 4066        return '<sdm.DB2I ' + \
 4067            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4068            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4069            'healthy: ' + repr(self.healthy) + ' ' +\
 4070            'hostname: ' + repr(self.hostname) + ' ' +\
 4071            'id: ' + repr(self.id) + ' ' +\
 4072            'name: ' + repr(self.name) + ' ' +\
 4073            'password: ' + repr(self.password) + ' ' +\
 4074            'port: ' + repr(self.port) + ' ' +\
 4075            'port_override: ' + repr(self.port_override) + ' ' +\
 4076            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4077            'tags: ' + repr(self.tags) + ' ' +\
 4078            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4079            'username: ' + repr(self.username) + ' ' +\
 4080            '>'
 4081
 4082    def to_dict(self):
 4083        return {
 4084            'bind_interface': self.bind_interface,
 4085            'egress_filter': self.egress_filter,
 4086            'healthy': self.healthy,
 4087            'hostname': self.hostname,
 4088            'id': self.id,
 4089            'name': self.name,
 4090            'password': self.password,
 4091            'port': self.port,
 4092            'port_override': self.port_override,
 4093            'secret_store_id': self.secret_store_id,
 4094            'tags': self.tags,
 4095            'tls_required': self.tls_required,
 4096            'username': self.username,
 4097        }
 4098
 4099    @classmethod
 4100    def from_dict(cls, d):
 4101        return cls(
 4102            bind_interface=d.get('bind_interface'),
 4103            egress_filter=d.get('egress_filter'),
 4104            healthy=d.get('healthy'),
 4105            hostname=d.get('hostname'),
 4106            id=d.get('id'),
 4107            name=d.get('name'),
 4108            password=d.get('password'),
 4109            port=d.get('port'),
 4110            port_override=d.get('port_override'),
 4111            secret_store_id=d.get('secret_store_id'),
 4112            tags=d.get('tags'),
 4113            tls_required=d.get('tls_required'),
 4114            username=d.get('username'),
 4115        )
 4116
 4117
 4118class DB2LUW:
 4119    '''
 4120
 4121    '''
 4122    __slots__ = [
 4123        'bind_interface',
 4124        'database',
 4125        'egress_filter',
 4126        'healthy',
 4127        'hostname',
 4128        'id',
 4129        'name',
 4130        'password',
 4131        'port',
 4132        'port_override',
 4133        'secret_store_id',
 4134        'tags',
 4135        'username',
 4136    ]
 4137
 4138    def __init__(
 4139        self,
 4140        bind_interface=None,
 4141        database=None,
 4142        egress_filter=None,
 4143        healthy=None,
 4144        hostname=None,
 4145        id=None,
 4146        name=None,
 4147        password=None,
 4148        port=None,
 4149        port_override=None,
 4150        secret_store_id=None,
 4151        tags=None,
 4152        username=None,
 4153    ):
 4154        self.bind_interface = bind_interface if bind_interface is not None else ''
 4155        '''
 4156         Bind interface
 4157        '''
 4158        self.database = database if database is not None else ''
 4159        '''
 4160
 4161        '''
 4162        self.egress_filter = egress_filter if egress_filter is not None else ''
 4163        '''
 4164         A filter applied to the routing logic to pin datasource to nodes.
 4165        '''
 4166        self.healthy = healthy if healthy is not None else False
 4167        '''
 4168         True if the datasource is reachable and the credentials are valid.
 4169        '''
 4170        self.hostname = hostname if hostname is not None else ''
 4171        '''
 4172
 4173        '''
 4174        self.id = id if id is not None else ''
 4175        '''
 4176         Unique identifier of the Resource.
 4177        '''
 4178        self.name = name if name is not None else ''
 4179        '''
 4180         Unique human-readable name of the Resource.
 4181        '''
 4182        self.password = password if password is not None else ''
 4183        '''
 4184
 4185        '''
 4186        self.port = port if port is not None else 0
 4187        '''
 4188
 4189        '''
 4190        self.port_override = port_override if port_override is not None else 0
 4191        '''
 4192
 4193        '''
 4194        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4195        '''
 4196         ID of the secret store containing credentials for this resource, if any.
 4197        '''
 4198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4199        '''
 4200         Tags is a map of key, value pairs.
 4201        '''
 4202        self.username = username if username is not None else ''
 4203        '''
 4204
 4205        '''
 4206
 4207    def __repr__(self):
 4208        return '<sdm.DB2LUW ' + \
 4209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4210            'database: ' + repr(self.database) + ' ' +\
 4211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4212            'healthy: ' + repr(self.healthy) + ' ' +\
 4213            'hostname: ' + repr(self.hostname) + ' ' +\
 4214            'id: ' + repr(self.id) + ' ' +\
 4215            'name: ' + repr(self.name) + ' ' +\
 4216            'password: ' + repr(self.password) + ' ' +\
 4217            'port: ' + repr(self.port) + ' ' +\
 4218            'port_override: ' + repr(self.port_override) + ' ' +\
 4219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4220            'tags: ' + repr(self.tags) + ' ' +\
 4221            'username: ' + repr(self.username) + ' ' +\
 4222            '>'
 4223
 4224    def to_dict(self):
 4225        return {
 4226            'bind_interface': self.bind_interface,
 4227            'database': self.database,
 4228            'egress_filter': self.egress_filter,
 4229            'healthy': self.healthy,
 4230            'hostname': self.hostname,
 4231            'id': self.id,
 4232            'name': self.name,
 4233            'password': self.password,
 4234            'port': self.port,
 4235            'port_override': self.port_override,
 4236            'secret_store_id': self.secret_store_id,
 4237            'tags': self.tags,
 4238            'username': self.username,
 4239        }
 4240
 4241    @classmethod
 4242    def from_dict(cls, d):
 4243        return cls(
 4244            bind_interface=d.get('bind_interface'),
 4245            database=d.get('database'),
 4246            egress_filter=d.get('egress_filter'),
 4247            healthy=d.get('healthy'),
 4248            hostname=d.get('hostname'),
 4249            id=d.get('id'),
 4250            name=d.get('name'),
 4251            password=d.get('password'),
 4252            port=d.get('port'),
 4253            port_override=d.get('port_override'),
 4254            secret_store_id=d.get('secret_store_id'),
 4255            tags=d.get('tags'),
 4256            username=d.get('username'),
 4257        )
 4258
 4259
 4260class DeleteResponseMetadata:
 4261    '''
 4262     DeleteResponseMetadata is reserved for future use.
 4263    '''
 4264    __slots__ = []
 4265
 4266    def __init__(self, ):
 4267        pass
 4268
 4269    def __repr__(self):
 4270        return '<sdm.DeleteResponseMetadata ' + \
 4271            '>'
 4272
 4273    def to_dict(self):
 4274        return {}
 4275
 4276    @classmethod
 4277    def from_dict(cls, d):
 4278        return cls()
 4279
 4280
 4281class DocumentDBHost:
 4282    '''
 4283
 4284    '''
 4285    __slots__ = [
 4286        'auth_database',
 4287        'bind_interface',
 4288        'egress_filter',
 4289        'healthy',
 4290        'hostname',
 4291        'id',
 4292        'name',
 4293        'password',
 4294        'port',
 4295        'port_override',
 4296        'secret_store_id',
 4297        'tags',
 4298        'username',
 4299    ]
 4300
 4301    def __init__(
 4302        self,
 4303        auth_database=None,
 4304        bind_interface=None,
 4305        egress_filter=None,
 4306        healthy=None,
 4307        hostname=None,
 4308        id=None,
 4309        name=None,
 4310        password=None,
 4311        port=None,
 4312        port_override=None,
 4313        secret_store_id=None,
 4314        tags=None,
 4315        username=None,
 4316    ):
 4317        self.auth_database = auth_database if auth_database is not None else ''
 4318        '''
 4319
 4320        '''
 4321        self.bind_interface = bind_interface if bind_interface is not None else ''
 4322        '''
 4323         Bind interface
 4324        '''
 4325        self.egress_filter = egress_filter if egress_filter is not None else ''
 4326        '''
 4327         A filter applied to the routing logic to pin datasource to nodes.
 4328        '''
 4329        self.healthy = healthy if healthy is not None else False
 4330        '''
 4331         True if the datasource is reachable and the credentials are valid.
 4332        '''
 4333        self.hostname = hostname if hostname is not None else ''
 4334        '''
 4335
 4336        '''
 4337        self.id = id if id is not None else ''
 4338        '''
 4339         Unique identifier of the Resource.
 4340        '''
 4341        self.name = name if name is not None else ''
 4342        '''
 4343         Unique human-readable name of the Resource.
 4344        '''
 4345        self.password = password if password is not None else ''
 4346        '''
 4347
 4348        '''
 4349        self.port = port if port is not None else 0
 4350        '''
 4351
 4352        '''
 4353        self.port_override = port_override if port_override is not None else 0
 4354        '''
 4355
 4356        '''
 4357        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4358        '''
 4359         ID of the secret store containing credentials for this resource, if any.
 4360        '''
 4361        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4362        '''
 4363         Tags is a map of key, value pairs.
 4364        '''
 4365        self.username = username if username is not None else ''
 4366        '''
 4367
 4368        '''
 4369
 4370    def __repr__(self):
 4371        return '<sdm.DocumentDBHost ' + \
 4372            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4373            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4374            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4375            'healthy: ' + repr(self.healthy) + ' ' +\
 4376            'hostname: ' + repr(self.hostname) + ' ' +\
 4377            'id: ' + repr(self.id) + ' ' +\
 4378            'name: ' + repr(self.name) + ' ' +\
 4379            'password: ' + repr(self.password) + ' ' +\
 4380            'port: ' + repr(self.port) + ' ' +\
 4381            'port_override: ' + repr(self.port_override) + ' ' +\
 4382            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4383            'tags: ' + repr(self.tags) + ' ' +\
 4384            'username: ' + repr(self.username) + ' ' +\
 4385            '>'
 4386
 4387    def to_dict(self):
 4388        return {
 4389            'auth_database': self.auth_database,
 4390            'bind_interface': self.bind_interface,
 4391            'egress_filter': self.egress_filter,
 4392            'healthy': self.healthy,
 4393            'hostname': self.hostname,
 4394            'id': self.id,
 4395            'name': self.name,
 4396            'password': self.password,
 4397            'port': self.port,
 4398            'port_override': self.port_override,
 4399            'secret_store_id': self.secret_store_id,
 4400            'tags': self.tags,
 4401            'username': self.username,
 4402        }
 4403
 4404    @classmethod
 4405    def from_dict(cls, d):
 4406        return cls(
 4407            auth_database=d.get('auth_database'),
 4408            bind_interface=d.get('bind_interface'),
 4409            egress_filter=d.get('egress_filter'),
 4410            healthy=d.get('healthy'),
 4411            hostname=d.get('hostname'),
 4412            id=d.get('id'),
 4413            name=d.get('name'),
 4414            password=d.get('password'),
 4415            port=d.get('port'),
 4416            port_override=d.get('port_override'),
 4417            secret_store_id=d.get('secret_store_id'),
 4418            tags=d.get('tags'),
 4419            username=d.get('username'),
 4420        )
 4421
 4422
 4423class DocumentDBReplicaSet:
 4424    '''
 4425
 4426    '''
 4427    __slots__ = [
 4428        'auth_database',
 4429        'bind_interface',
 4430        'connect_to_replica',
 4431        'egress_filter',
 4432        'healthy',
 4433        'hostname',
 4434        'id',
 4435        'name',
 4436        'password',
 4437        'port_override',
 4438        'replica_set',
 4439        'secret_store_id',
 4440        'tags',
 4441        'username',
 4442    ]
 4443
 4444    def __init__(
 4445        self,
 4446        auth_database=None,
 4447        bind_interface=None,
 4448        connect_to_replica=None,
 4449        egress_filter=None,
 4450        healthy=None,
 4451        hostname=None,
 4452        id=None,
 4453        name=None,
 4454        password=None,
 4455        port_override=None,
 4456        replica_set=None,
 4457        secret_store_id=None,
 4458        tags=None,
 4459        username=None,
 4460    ):
 4461        self.auth_database = auth_database if auth_database is not None else ''
 4462        '''
 4463
 4464        '''
 4465        self.bind_interface = bind_interface if bind_interface is not None else ''
 4466        '''
 4467         Bind interface
 4468        '''
 4469        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4470        '''
 4471
 4472        '''
 4473        self.egress_filter = egress_filter if egress_filter is not None else ''
 4474        '''
 4475         A filter applied to the routing logic to pin datasource to nodes.
 4476        '''
 4477        self.healthy = healthy if healthy is not None else False
 4478        '''
 4479         True if the datasource is reachable and the credentials are valid.
 4480        '''
 4481        self.hostname = hostname if hostname is not None else ''
 4482        '''
 4483         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4484        '''
 4485        self.id = id if id is not None else ''
 4486        '''
 4487         Unique identifier of the Resource.
 4488        '''
 4489        self.name = name if name is not None else ''
 4490        '''
 4491         Unique human-readable name of the Resource.
 4492        '''
 4493        self.password = password if password is not None else ''
 4494        '''
 4495
 4496        '''
 4497        self.port_override = port_override if port_override is not None else 0
 4498        '''
 4499
 4500        '''
 4501        self.replica_set = replica_set if replica_set is not None else ''
 4502        '''
 4503
 4504        '''
 4505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4506        '''
 4507         ID of the secret store containing credentials for this resource, if any.
 4508        '''
 4509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4510        '''
 4511         Tags is a map of key, value pairs.
 4512        '''
 4513        self.username = username if username is not None else ''
 4514        '''
 4515
 4516        '''
 4517
 4518    def __repr__(self):
 4519        return '<sdm.DocumentDBReplicaSet ' + \
 4520            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4521            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4522            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4523            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4524            'healthy: ' + repr(self.healthy) + ' ' +\
 4525            'hostname: ' + repr(self.hostname) + ' ' +\
 4526            'id: ' + repr(self.id) + ' ' +\
 4527            'name: ' + repr(self.name) + ' ' +\
 4528            'password: ' + repr(self.password) + ' ' +\
 4529            'port_override: ' + repr(self.port_override) + ' ' +\
 4530            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4531            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4532            'tags: ' + repr(self.tags) + ' ' +\
 4533            'username: ' + repr(self.username) + ' ' +\
 4534            '>'
 4535
 4536    def to_dict(self):
 4537        return {
 4538            'auth_database': self.auth_database,
 4539            'bind_interface': self.bind_interface,
 4540            'connect_to_replica': self.connect_to_replica,
 4541            'egress_filter': self.egress_filter,
 4542            'healthy': self.healthy,
 4543            'hostname': self.hostname,
 4544            'id': self.id,
 4545            'name': self.name,
 4546            'password': self.password,
 4547            'port_override': self.port_override,
 4548            'replica_set': self.replica_set,
 4549            'secret_store_id': self.secret_store_id,
 4550            'tags': self.tags,
 4551            'username': self.username,
 4552        }
 4553
 4554    @classmethod
 4555    def from_dict(cls, d):
 4556        return cls(
 4557            auth_database=d.get('auth_database'),
 4558            bind_interface=d.get('bind_interface'),
 4559            connect_to_replica=d.get('connect_to_replica'),
 4560            egress_filter=d.get('egress_filter'),
 4561            healthy=d.get('healthy'),
 4562            hostname=d.get('hostname'),
 4563            id=d.get('id'),
 4564            name=d.get('name'),
 4565            password=d.get('password'),
 4566            port_override=d.get('port_override'),
 4567            replica_set=d.get('replica_set'),
 4568            secret_store_id=d.get('secret_store_id'),
 4569            tags=d.get('tags'),
 4570            username=d.get('username'),
 4571        )
 4572
 4573
 4574class Druid:
 4575    '''
 4576
 4577    '''
 4578    __slots__ = [
 4579        'bind_interface',
 4580        'egress_filter',
 4581        'healthy',
 4582        'hostname',
 4583        'id',
 4584        'name',
 4585        'password',
 4586        'port',
 4587        'port_override',
 4588        'secret_store_id',
 4589        'tags',
 4590        'username',
 4591    ]
 4592
 4593    def __init__(
 4594        self,
 4595        bind_interface=None,
 4596        egress_filter=None,
 4597        healthy=None,
 4598        hostname=None,
 4599        id=None,
 4600        name=None,
 4601        password=None,
 4602        port=None,
 4603        port_override=None,
 4604        secret_store_id=None,
 4605        tags=None,
 4606        username=None,
 4607    ):
 4608        self.bind_interface = bind_interface if bind_interface is not None else ''
 4609        '''
 4610         Bind interface
 4611        '''
 4612        self.egress_filter = egress_filter if egress_filter is not None else ''
 4613        '''
 4614         A filter applied to the routing logic to pin datasource to nodes.
 4615        '''
 4616        self.healthy = healthy if healthy is not None else False
 4617        '''
 4618         True if the datasource is reachable and the credentials are valid.
 4619        '''
 4620        self.hostname = hostname if hostname is not None else ''
 4621        '''
 4622
 4623        '''
 4624        self.id = id if id is not None else ''
 4625        '''
 4626         Unique identifier of the Resource.
 4627        '''
 4628        self.name = name if name is not None else ''
 4629        '''
 4630         Unique human-readable name of the Resource.
 4631        '''
 4632        self.password = password if password is not None else ''
 4633        '''
 4634
 4635        '''
 4636        self.port = port if port is not None else 0
 4637        '''
 4638
 4639        '''
 4640        self.port_override = port_override if port_override is not None else 0
 4641        '''
 4642
 4643        '''
 4644        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4645        '''
 4646         ID of the secret store containing credentials for this resource, if any.
 4647        '''
 4648        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4649        '''
 4650         Tags is a map of key, value pairs.
 4651        '''
 4652        self.username = username if username is not None else ''
 4653        '''
 4654
 4655        '''
 4656
 4657    def __repr__(self):
 4658        return '<sdm.Druid ' + \
 4659            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4660            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4661            'healthy: ' + repr(self.healthy) + ' ' +\
 4662            'hostname: ' + repr(self.hostname) + ' ' +\
 4663            'id: ' + repr(self.id) + ' ' +\
 4664            'name: ' + repr(self.name) + ' ' +\
 4665            'password: ' + repr(self.password) + ' ' +\
 4666            'port: ' + repr(self.port) + ' ' +\
 4667            'port_override: ' + repr(self.port_override) + ' ' +\
 4668            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4669            'tags: ' + repr(self.tags) + ' ' +\
 4670            'username: ' + repr(self.username) + ' ' +\
 4671            '>'
 4672
 4673    def to_dict(self):
 4674        return {
 4675            'bind_interface': self.bind_interface,
 4676            'egress_filter': self.egress_filter,
 4677            'healthy': self.healthy,
 4678            'hostname': self.hostname,
 4679            'id': self.id,
 4680            'name': self.name,
 4681            'password': self.password,
 4682            'port': self.port,
 4683            'port_override': self.port_override,
 4684            'secret_store_id': self.secret_store_id,
 4685            'tags': self.tags,
 4686            'username': self.username,
 4687        }
 4688
 4689    @classmethod
 4690    def from_dict(cls, d):
 4691        return cls(
 4692            bind_interface=d.get('bind_interface'),
 4693            egress_filter=d.get('egress_filter'),
 4694            healthy=d.get('healthy'),
 4695            hostname=d.get('hostname'),
 4696            id=d.get('id'),
 4697            name=d.get('name'),
 4698            password=d.get('password'),
 4699            port=d.get('port'),
 4700            port_override=d.get('port_override'),
 4701            secret_store_id=d.get('secret_store_id'),
 4702            tags=d.get('tags'),
 4703            username=d.get('username'),
 4704        )
 4705
 4706
 4707class DynamoDB:
 4708    '''
 4709
 4710    '''
 4711    __slots__ = [
 4712        'access_key',
 4713        'bind_interface',
 4714        'egress_filter',
 4715        'endpoint',
 4716        'healthy',
 4717        'id',
 4718        'name',
 4719        'port_override',
 4720        'region',
 4721        'role_arn',
 4722        'role_external_id',
 4723        'secret_access_key',
 4724        'secret_store_id',
 4725        'tags',
 4726    ]
 4727
 4728    def __init__(
 4729        self,
 4730        access_key=None,
 4731        bind_interface=None,
 4732        egress_filter=None,
 4733        endpoint=None,
 4734        healthy=None,
 4735        id=None,
 4736        name=None,
 4737        port_override=None,
 4738        region=None,
 4739        role_arn=None,
 4740        role_external_id=None,
 4741        secret_access_key=None,
 4742        secret_store_id=None,
 4743        tags=None,
 4744    ):
 4745        self.access_key = access_key if access_key is not None else ''
 4746        '''
 4747
 4748        '''
 4749        self.bind_interface = bind_interface if bind_interface is not None else ''
 4750        '''
 4751         Bind interface
 4752        '''
 4753        self.egress_filter = egress_filter if egress_filter is not None else ''
 4754        '''
 4755         A filter applied to the routing logic to pin datasource to nodes.
 4756        '''
 4757        self.endpoint = endpoint if endpoint is not None else ''
 4758        '''
 4759
 4760        '''
 4761        self.healthy = healthy if healthy is not None else False
 4762        '''
 4763         True if the datasource is reachable and the credentials are valid.
 4764        '''
 4765        self.id = id if id is not None else ''
 4766        '''
 4767         Unique identifier of the Resource.
 4768        '''
 4769        self.name = name if name is not None else ''
 4770        '''
 4771         Unique human-readable name of the Resource.
 4772        '''
 4773        self.port_override = port_override if port_override is not None else 0
 4774        '''
 4775
 4776        '''
 4777        self.region = region if region is not None else ''
 4778        '''
 4779
 4780        '''
 4781        self.role_arn = role_arn if role_arn is not None else ''
 4782        '''
 4783
 4784        '''
 4785        self.role_external_id = role_external_id if role_external_id is not None else ''
 4786        '''
 4787
 4788        '''
 4789        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4790        '''
 4791
 4792        '''
 4793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4794        '''
 4795         ID of the secret store containing credentials for this resource, if any.
 4796        '''
 4797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4798        '''
 4799         Tags is a map of key, value pairs.
 4800        '''
 4801
 4802    def __repr__(self):
 4803        return '<sdm.DynamoDB ' + \
 4804            'access_key: ' + repr(self.access_key) + ' ' +\
 4805            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4807            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4808            'healthy: ' + repr(self.healthy) + ' ' +\
 4809            'id: ' + repr(self.id) + ' ' +\
 4810            'name: ' + repr(self.name) + ' ' +\
 4811            'port_override: ' + repr(self.port_override) + ' ' +\
 4812            'region: ' + repr(self.region) + ' ' +\
 4813            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4814            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4815            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4817            'tags: ' + repr(self.tags) + ' ' +\
 4818            '>'
 4819
 4820    def to_dict(self):
 4821        return {
 4822            'access_key': self.access_key,
 4823            'bind_interface': self.bind_interface,
 4824            'egress_filter': self.egress_filter,
 4825            'endpoint': self.endpoint,
 4826            'healthy': self.healthy,
 4827            'id': self.id,
 4828            'name': self.name,
 4829            'port_override': self.port_override,
 4830            'region': self.region,
 4831            'role_arn': self.role_arn,
 4832            'role_external_id': self.role_external_id,
 4833            'secret_access_key': self.secret_access_key,
 4834            'secret_store_id': self.secret_store_id,
 4835            'tags': self.tags,
 4836        }
 4837
 4838    @classmethod
 4839    def from_dict(cls, d):
 4840        return cls(
 4841            access_key=d.get('access_key'),
 4842            bind_interface=d.get('bind_interface'),
 4843            egress_filter=d.get('egress_filter'),
 4844            endpoint=d.get('endpoint'),
 4845            healthy=d.get('healthy'),
 4846            id=d.get('id'),
 4847            name=d.get('name'),
 4848            port_override=d.get('port_override'),
 4849            region=d.get('region'),
 4850            role_arn=d.get('role_arn'),
 4851            role_external_id=d.get('role_external_id'),
 4852            secret_access_key=d.get('secret_access_key'),
 4853            secret_store_id=d.get('secret_store_id'),
 4854            tags=d.get('tags'),
 4855        )
 4856
 4857
 4858class Elastic:
 4859    '''
 4860
 4861    '''
 4862    __slots__ = [
 4863        'bind_interface',
 4864        'egress_filter',
 4865        'healthy',
 4866        'hostname',
 4867        'id',
 4868        'name',
 4869        'password',
 4870        'port',
 4871        'port_override',
 4872        'secret_store_id',
 4873        'tags',
 4874        'tls_required',
 4875        'username',
 4876    ]
 4877
 4878    def __init__(
 4879        self,
 4880        bind_interface=None,
 4881        egress_filter=None,
 4882        healthy=None,
 4883        hostname=None,
 4884        id=None,
 4885        name=None,
 4886        password=None,
 4887        port=None,
 4888        port_override=None,
 4889        secret_store_id=None,
 4890        tags=None,
 4891        tls_required=None,
 4892        username=None,
 4893    ):
 4894        self.bind_interface = bind_interface if bind_interface is not None else ''
 4895        '''
 4896         Bind interface
 4897        '''
 4898        self.egress_filter = egress_filter if egress_filter is not None else ''
 4899        '''
 4900         A filter applied to the routing logic to pin datasource to nodes.
 4901        '''
 4902        self.healthy = healthy if healthy is not None else False
 4903        '''
 4904         True if the datasource is reachable and the credentials are valid.
 4905        '''
 4906        self.hostname = hostname if hostname is not None else ''
 4907        '''
 4908
 4909        '''
 4910        self.id = id if id is not None else ''
 4911        '''
 4912         Unique identifier of the Resource.
 4913        '''
 4914        self.name = name if name is not None else ''
 4915        '''
 4916         Unique human-readable name of the Resource.
 4917        '''
 4918        self.password = password if password is not None else ''
 4919        '''
 4920
 4921        '''
 4922        self.port = port if port is not None else 0
 4923        '''
 4924
 4925        '''
 4926        self.port_override = port_override if port_override is not None else 0
 4927        '''
 4928
 4929        '''
 4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4931        '''
 4932         ID of the secret store containing credentials for this resource, if any.
 4933        '''
 4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4935        '''
 4936         Tags is a map of key, value pairs.
 4937        '''
 4938        self.tls_required = tls_required if tls_required is not None else False
 4939        '''
 4940
 4941        '''
 4942        self.username = username if username is not None else ''
 4943        '''
 4944
 4945        '''
 4946
 4947    def __repr__(self):
 4948        return '<sdm.Elastic ' + \
 4949            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4950            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4951            'healthy: ' + repr(self.healthy) + ' ' +\
 4952            'hostname: ' + repr(self.hostname) + ' ' +\
 4953            'id: ' + repr(self.id) + ' ' +\
 4954            'name: ' + repr(self.name) + ' ' +\
 4955            'password: ' + repr(self.password) + ' ' +\
 4956            'port: ' + repr(self.port) + ' ' +\
 4957            'port_override: ' + repr(self.port_override) + ' ' +\
 4958            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4959            'tags: ' + repr(self.tags) + ' ' +\
 4960            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4961            'username: ' + repr(self.username) + ' ' +\
 4962            '>'
 4963
 4964    def to_dict(self):
 4965        return {
 4966            'bind_interface': self.bind_interface,
 4967            'egress_filter': self.egress_filter,
 4968            'healthy': self.healthy,
 4969            'hostname': self.hostname,
 4970            'id': self.id,
 4971            'name': self.name,
 4972            'password': self.password,
 4973            'port': self.port,
 4974            'port_override': self.port_override,
 4975            'secret_store_id': self.secret_store_id,
 4976            'tags': self.tags,
 4977            'tls_required': self.tls_required,
 4978            'username': self.username,
 4979        }
 4980
 4981    @classmethod
 4982    def from_dict(cls, d):
 4983        return cls(
 4984            bind_interface=d.get('bind_interface'),
 4985            egress_filter=d.get('egress_filter'),
 4986            healthy=d.get('healthy'),
 4987            hostname=d.get('hostname'),
 4988            id=d.get('id'),
 4989            name=d.get('name'),
 4990            password=d.get('password'),
 4991            port=d.get('port'),
 4992            port_override=d.get('port_override'),
 4993            secret_store_id=d.get('secret_store_id'),
 4994            tags=d.get('tags'),
 4995            tls_required=d.get('tls_required'),
 4996            username=d.get('username'),
 4997        )
 4998
 4999
 5000class ElasticacheRedis:
 5001    '''
 5002
 5003    '''
 5004    __slots__ = [
 5005        'bind_interface',
 5006        'egress_filter',
 5007        'healthy',
 5008        'hostname',
 5009        'id',
 5010        'name',
 5011        'password',
 5012        'port',
 5013        'port_override',
 5014        'secret_store_id',
 5015        'tags',
 5016        'tls_required',
 5017    ]
 5018
 5019    def __init__(
 5020        self,
 5021        bind_interface=None,
 5022        egress_filter=None,
 5023        healthy=None,
 5024        hostname=None,
 5025        id=None,
 5026        name=None,
 5027        password=None,
 5028        port=None,
 5029        port_override=None,
 5030        secret_store_id=None,
 5031        tags=None,
 5032        tls_required=None,
 5033    ):
 5034        self.bind_interface = bind_interface if bind_interface is not None else ''
 5035        '''
 5036         Bind interface
 5037        '''
 5038        self.egress_filter = egress_filter if egress_filter is not None else ''
 5039        '''
 5040         A filter applied to the routing logic to pin datasource to nodes.
 5041        '''
 5042        self.healthy = healthy if healthy is not None else False
 5043        '''
 5044         True if the datasource is reachable and the credentials are valid.
 5045        '''
 5046        self.hostname = hostname if hostname is not None else ''
 5047        '''
 5048
 5049        '''
 5050        self.id = id if id is not None else ''
 5051        '''
 5052         Unique identifier of the Resource.
 5053        '''
 5054        self.name = name if name is not None else ''
 5055        '''
 5056         Unique human-readable name of the Resource.
 5057        '''
 5058        self.password = password if password is not None else ''
 5059        '''
 5060
 5061        '''
 5062        self.port = port if port is not None else 0
 5063        '''
 5064
 5065        '''
 5066        self.port_override = port_override if port_override is not None else 0
 5067        '''
 5068
 5069        '''
 5070        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5071        '''
 5072         ID of the secret store containing credentials for this resource, if any.
 5073        '''
 5074        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5075        '''
 5076         Tags is a map of key, value pairs.
 5077        '''
 5078        self.tls_required = tls_required if tls_required is not None else False
 5079        '''
 5080
 5081        '''
 5082
 5083    def __repr__(self):
 5084        return '<sdm.ElasticacheRedis ' + \
 5085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5087            'healthy: ' + repr(self.healthy) + ' ' +\
 5088            'hostname: ' + repr(self.hostname) + ' ' +\
 5089            'id: ' + repr(self.id) + ' ' +\
 5090            'name: ' + repr(self.name) + ' ' +\
 5091            'password: ' + repr(self.password) + ' ' +\
 5092            'port: ' + repr(self.port) + ' ' +\
 5093            'port_override: ' + repr(self.port_override) + ' ' +\
 5094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5095            'tags: ' + repr(self.tags) + ' ' +\
 5096            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5097            '>'
 5098
 5099    def to_dict(self):
 5100        return {
 5101            'bind_interface': self.bind_interface,
 5102            'egress_filter': self.egress_filter,
 5103            'healthy': self.healthy,
 5104            'hostname': self.hostname,
 5105            'id': self.id,
 5106            'name': self.name,
 5107            'password': self.password,
 5108            'port': self.port,
 5109            'port_override': self.port_override,
 5110            'secret_store_id': self.secret_store_id,
 5111            'tags': self.tags,
 5112            'tls_required': self.tls_required,
 5113        }
 5114
 5115    @classmethod
 5116    def from_dict(cls, d):
 5117        return cls(
 5118            bind_interface=d.get('bind_interface'),
 5119            egress_filter=d.get('egress_filter'),
 5120            healthy=d.get('healthy'),
 5121            hostname=d.get('hostname'),
 5122            id=d.get('id'),
 5123            name=d.get('name'),
 5124            password=d.get('password'),
 5125            port=d.get('port'),
 5126            port_override=d.get('port_override'),
 5127            secret_store_id=d.get('secret_store_id'),
 5128            tags=d.get('tags'),
 5129            tls_required=d.get('tls_required'),
 5130        )
 5131
 5132
 5133class GCP:
 5134    '''
 5135
 5136    '''
 5137    __slots__ = [
 5138        'bind_interface',
 5139        'egress_filter',
 5140        'healthy',
 5141        'id',
 5142        'keyfile',
 5143        'name',
 5144        'scopes',
 5145        'secret_store_id',
 5146        'tags',
 5147    ]
 5148
 5149    def __init__(
 5150        self,
 5151        bind_interface=None,
 5152        egress_filter=None,
 5153        healthy=None,
 5154        id=None,
 5155        keyfile=None,
 5156        name=None,
 5157        scopes=None,
 5158        secret_store_id=None,
 5159        tags=None,
 5160    ):
 5161        self.bind_interface = bind_interface if bind_interface is not None else ''
 5162        '''
 5163         Bind interface
 5164        '''
 5165        self.egress_filter = egress_filter if egress_filter is not None else ''
 5166        '''
 5167         A filter applied to the routing logic to pin datasource to nodes.
 5168        '''
 5169        self.healthy = healthy if healthy is not None else False
 5170        '''
 5171         True if the datasource is reachable and the credentials are valid.
 5172        '''
 5173        self.id = id if id is not None else ''
 5174        '''
 5175         Unique identifier of the Resource.
 5176        '''
 5177        self.keyfile = keyfile if keyfile is not None else ''
 5178        '''
 5179
 5180        '''
 5181        self.name = name if name is not None else ''
 5182        '''
 5183         Unique human-readable name of the Resource.
 5184        '''
 5185        self.scopes = scopes if scopes is not None else ''
 5186        '''
 5187
 5188        '''
 5189        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5190        '''
 5191         ID of the secret store containing credentials for this resource, if any.
 5192        '''
 5193        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5194        '''
 5195         Tags is a map of key, value pairs.
 5196        '''
 5197
 5198    def __repr__(self):
 5199        return '<sdm.GCP ' + \
 5200            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5201            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5202            'healthy: ' + repr(self.healthy) + ' ' +\
 5203            'id: ' + repr(self.id) + ' ' +\
 5204            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5205            'name: ' + repr(self.name) + ' ' +\
 5206            'scopes: ' + repr(self.scopes) + ' ' +\
 5207            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5208            'tags: ' + repr(self.tags) + ' ' +\
 5209            '>'
 5210
 5211    def to_dict(self):
 5212        return {
 5213            'bind_interface': self.bind_interface,
 5214            'egress_filter': self.egress_filter,
 5215            'healthy': self.healthy,
 5216            'id': self.id,
 5217            'keyfile': self.keyfile,
 5218            'name': self.name,
 5219            'scopes': self.scopes,
 5220            'secret_store_id': self.secret_store_id,
 5221            'tags': self.tags,
 5222        }
 5223
 5224    @classmethod
 5225    def from_dict(cls, d):
 5226        return cls(
 5227            bind_interface=d.get('bind_interface'),
 5228            egress_filter=d.get('egress_filter'),
 5229            healthy=d.get('healthy'),
 5230            id=d.get('id'),
 5231            keyfile=d.get('keyfile'),
 5232            name=d.get('name'),
 5233            scopes=d.get('scopes'),
 5234            secret_store_id=d.get('secret_store_id'),
 5235            tags=d.get('tags'),
 5236        )
 5237
 5238
 5239class GCPStore:
 5240    '''
 5241
 5242    '''
 5243    __slots__ = [
 5244        'id',
 5245        'name',
 5246        'projectid',
 5247        'tags',
 5248    ]
 5249
 5250    def __init__(
 5251        self,
 5252        id=None,
 5253        name=None,
 5254        projectid=None,
 5255        tags=None,
 5256    ):
 5257        self.id = id if id is not None else ''
 5258        '''
 5259         Unique identifier of the SecretStore.
 5260        '''
 5261        self.name = name if name is not None else ''
 5262        '''
 5263         Unique human-readable name of the SecretStore.
 5264        '''
 5265        self.projectid = projectid if projectid is not None else ''
 5266        '''
 5267
 5268        '''
 5269        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5270        '''
 5271         Tags is a map of key, value pairs.
 5272        '''
 5273
 5274    def __repr__(self):
 5275        return '<sdm.GCPStore ' + \
 5276            'id: ' + repr(self.id) + ' ' +\
 5277            'name: ' + repr(self.name) + ' ' +\
 5278            'projectid: ' + repr(self.projectid) + ' ' +\
 5279            'tags: ' + repr(self.tags) + ' ' +\
 5280            '>'
 5281
 5282    def to_dict(self):
 5283        return {
 5284            'id': self.id,
 5285            'name': self.name,
 5286            'projectid': self.projectid,
 5287            'tags': self.tags,
 5288        }
 5289
 5290    @classmethod
 5291    def from_dict(cls, d):
 5292        return cls(
 5293            id=d.get('id'),
 5294            name=d.get('name'),
 5295            projectid=d.get('projectid'),
 5296            tags=d.get('tags'),
 5297        )
 5298
 5299
 5300class Gateway:
 5301    '''
 5302     Gateway represents a StrongDM CLI installation running in gateway mode.
 5303    '''
 5304    __slots__ = [
 5305        'bind_address',
 5306        'gateway_filter',
 5307        'id',
 5308        'listen_address',
 5309        'name',
 5310        'state',
 5311        'tags',
 5312    ]
 5313
 5314    def __init__(
 5315        self,
 5316        bind_address=None,
 5317        gateway_filter=None,
 5318        id=None,
 5319        listen_address=None,
 5320        name=None,
 5321        state=None,
 5322        tags=None,
 5323    ):
 5324        self.bind_address = bind_address if bind_address is not None else ''
 5325        '''
 5326         The hostname/port tuple which the gateway daemon will bind to.
 5327         If not provided on create, set to "0.0.0.0:listen_address_port".
 5328        '''
 5329        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5330        '''
 5331         GatewayFilter can be used to restrict the peering between relays and
 5332         gateways.
 5333        '''
 5334        self.id = id if id is not None else ''
 5335        '''
 5336         Unique identifier of the Gateway.
 5337        '''
 5338        self.listen_address = listen_address if listen_address is not None else ''
 5339        '''
 5340         The public hostname/port tuple at which the gateway will be accessible to clients.
 5341        '''
 5342        self.name = name if name is not None else ''
 5343        '''
 5344         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5345        '''
 5346        self.state = state if state is not None else ''
 5347        '''
 5348         The current state of the gateway. One of: "new", "verifying_restart",
 5349         "restarting", "started", "stopped", "dead", "unknown"
 5350        '''
 5351        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5352        '''
 5353         Tags is a map of key, value pairs.
 5354        '''
 5355
 5356    def __repr__(self):
 5357        return '<sdm.Gateway ' + \
 5358            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5359            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5360            'id: ' + repr(self.id) + ' ' +\
 5361            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5362            'name: ' + repr(self.name) + ' ' +\
 5363            'state: ' + repr(self.state) + ' ' +\
 5364            'tags: ' + repr(self.tags) + ' ' +\
 5365            '>'
 5366
 5367    def to_dict(self):
 5368        return {
 5369            'bind_address': self.bind_address,
 5370            'gateway_filter': self.gateway_filter,
 5371            'id': self.id,
 5372            'listen_address': self.listen_address,
 5373            'name': self.name,
 5374            'state': self.state,
 5375            'tags': self.tags,
 5376        }
 5377
 5378    @classmethod
 5379    def from_dict(cls, d):
 5380        return cls(
 5381            bind_address=d.get('bind_address'),
 5382            gateway_filter=d.get('gateway_filter'),
 5383            id=d.get('id'),
 5384            listen_address=d.get('listen_address'),
 5385            name=d.get('name'),
 5386            state=d.get('state'),
 5387            tags=d.get('tags'),
 5388        )
 5389
 5390
 5391class GetResponseMetadata:
 5392    '''
 5393     GetResponseMetadata is reserved for future use.
 5394    '''
 5395    __slots__ = []
 5396
 5397    def __init__(self, ):
 5398        pass
 5399
 5400    def __repr__(self):
 5401        return '<sdm.GetResponseMetadata ' + \
 5402            '>'
 5403
 5404    def to_dict(self):
 5405        return {}
 5406
 5407    @classmethod
 5408    def from_dict(cls, d):
 5409        return cls()
 5410
 5411
 5412class GoogleGKE:
 5413    '''
 5414
 5415    '''
 5416    __slots__ = [
 5417        'bind_interface',
 5418        'certificate_authority',
 5419        'egress_filter',
 5420        'endpoint',
 5421        'healthcheck_namespace',
 5422        'healthy',
 5423        'id',
 5424        'name',
 5425        'remote_identity_group_id',
 5426        'remote_identity_healthcheck_username',
 5427        'secret_store_id',
 5428        'service_account_key',
 5429        'tags',
 5430    ]
 5431
 5432    def __init__(
 5433        self,
 5434        bind_interface=None,
 5435        certificate_authority=None,
 5436        egress_filter=None,
 5437        endpoint=None,
 5438        healthcheck_namespace=None,
 5439        healthy=None,
 5440        id=None,
 5441        name=None,
 5442        remote_identity_group_id=None,
 5443        remote_identity_healthcheck_username=None,
 5444        secret_store_id=None,
 5445        service_account_key=None,
 5446        tags=None,
 5447    ):
 5448        self.bind_interface = bind_interface if bind_interface is not None else ''
 5449        '''
 5450         Bind interface
 5451        '''
 5452        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5453        '''
 5454
 5455        '''
 5456        self.egress_filter = egress_filter if egress_filter is not None else ''
 5457        '''
 5458         A filter applied to the routing logic to pin datasource to nodes.
 5459        '''
 5460        self.endpoint = endpoint if endpoint is not None else ''
 5461        '''
 5462
 5463        '''
 5464        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5465        '''
 5466         The path used to check the health of your connection.  Defaults to `default`.
 5467        '''
 5468        self.healthy = healthy if healthy is not None else False
 5469        '''
 5470         True if the datasource is reachable and the credentials are valid.
 5471        '''
 5472        self.id = id if id is not None else ''
 5473        '''
 5474         Unique identifier of the Resource.
 5475        '''
 5476        self.name = name if name is not None else ''
 5477        '''
 5478         Unique human-readable name of the Resource.
 5479        '''
 5480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5481        '''
 5482
 5483        '''
 5484        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5485        '''
 5486
 5487        '''
 5488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5489        '''
 5490         ID of the secret store containing credentials for this resource, if any.
 5491        '''
 5492        self.service_account_key = service_account_key if service_account_key is not None else ''
 5493        '''
 5494
 5495        '''
 5496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5497        '''
 5498         Tags is a map of key, value pairs.
 5499        '''
 5500
 5501    def __repr__(self):
 5502        return '<sdm.GoogleGKE ' + \
 5503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5504            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5506            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5507            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5508            'healthy: ' + repr(self.healthy) + ' ' +\
 5509            'id: ' + repr(self.id) + ' ' +\
 5510            'name: ' + repr(self.name) + ' ' +\
 5511            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5512            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5513            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5514            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5515            'tags: ' + repr(self.tags) + ' ' +\
 5516            '>'
 5517
 5518    def to_dict(self):
 5519        return {
 5520            'bind_interface': self.bind_interface,
 5521            'certificate_authority': self.certificate_authority,
 5522            'egress_filter': self.egress_filter,
 5523            'endpoint': self.endpoint,
 5524            'healthcheck_namespace': self.healthcheck_namespace,
 5525            'healthy': self.healthy,
 5526            'id': self.id,
 5527            'name': self.name,
 5528            'remote_identity_group_id': self.remote_identity_group_id,
 5529            'remote_identity_healthcheck_username':
 5530            self.remote_identity_healthcheck_username,
 5531            'secret_store_id': self.secret_store_id,
 5532            'service_account_key': self.service_account_key,
 5533            'tags': self.tags,
 5534        }
 5535
 5536    @classmethod
 5537    def from_dict(cls, d):
 5538        return cls(
 5539            bind_interface=d.get('bind_interface'),
 5540            certificate_authority=d.get('certificate_authority'),
 5541            egress_filter=d.get('egress_filter'),
 5542            endpoint=d.get('endpoint'),
 5543            healthcheck_namespace=d.get('healthcheck_namespace'),
 5544            healthy=d.get('healthy'),
 5545            id=d.get('id'),
 5546            name=d.get('name'),
 5547            remote_identity_group_id=d.get('remote_identity_group_id'),
 5548            remote_identity_healthcheck_username=d.get(
 5549                'remote_identity_healthcheck_username'),
 5550            secret_store_id=d.get('secret_store_id'),
 5551            service_account_key=d.get('service_account_key'),
 5552            tags=d.get('tags'),
 5553        )
 5554
 5555
 5556class GoogleGKEUserImpersonation:
 5557    '''
 5558
 5559    '''
 5560    __slots__ = [
 5561        'bind_interface',
 5562        'certificate_authority',
 5563        'egress_filter',
 5564        'endpoint',
 5565        'healthcheck_namespace',
 5566        'healthy',
 5567        'id',
 5568        'name',
 5569        'secret_store_id',
 5570        'service_account_key',
 5571        'tags',
 5572    ]
 5573
 5574    def __init__(
 5575        self,
 5576        bind_interface=None,
 5577        certificate_authority=None,
 5578        egress_filter=None,
 5579        endpoint=None,
 5580        healthcheck_namespace=None,
 5581        healthy=None,
 5582        id=None,
 5583        name=None,
 5584        secret_store_id=None,
 5585        service_account_key=None,
 5586        tags=None,
 5587    ):
 5588        self.bind_interface = bind_interface if bind_interface is not None else ''
 5589        '''
 5590         Bind interface
 5591        '''
 5592        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5593        '''
 5594
 5595        '''
 5596        self.egress_filter = egress_filter if egress_filter is not None else ''
 5597        '''
 5598         A filter applied to the routing logic to pin datasource to nodes.
 5599        '''
 5600        self.endpoint = endpoint if endpoint is not None else ''
 5601        '''
 5602
 5603        '''
 5604        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5605        '''
 5606         The path used to check the health of your connection.  Defaults to `default`.
 5607        '''
 5608        self.healthy = healthy if healthy is not None else False
 5609        '''
 5610         True if the datasource is reachable and the credentials are valid.
 5611        '''
 5612        self.id = id if id is not None else ''
 5613        '''
 5614         Unique identifier of the Resource.
 5615        '''
 5616        self.name = name if name is not None else ''
 5617        '''
 5618         Unique human-readable name of the Resource.
 5619        '''
 5620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5621        '''
 5622         ID of the secret store containing credentials for this resource, if any.
 5623        '''
 5624        self.service_account_key = service_account_key if service_account_key is not None else ''
 5625        '''
 5626
 5627        '''
 5628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5629        '''
 5630         Tags is a map of key, value pairs.
 5631        '''
 5632
 5633    def __repr__(self):
 5634        return '<sdm.GoogleGKEUserImpersonation ' + \
 5635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5636            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5638            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5639            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5640            'healthy: ' + repr(self.healthy) + ' ' +\
 5641            'id: ' + repr(self.id) + ' ' +\
 5642            'name: ' + repr(self.name) + ' ' +\
 5643            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5644            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5645            'tags: ' + repr(self.tags) + ' ' +\
 5646            '>'
 5647
 5648    def to_dict(self):
 5649        return {
 5650            'bind_interface': self.bind_interface,
 5651            'certificate_authority': self.certificate_authority,
 5652            'egress_filter': self.egress_filter,
 5653            'endpoint': self.endpoint,
 5654            'healthcheck_namespace': self.healthcheck_namespace,
 5655            'healthy': self.healthy,
 5656            'id': self.id,
 5657            'name': self.name,
 5658            'secret_store_id': self.secret_store_id,
 5659            'service_account_key': self.service_account_key,
 5660            'tags': self.tags,
 5661        }
 5662
 5663    @classmethod
 5664    def from_dict(cls, d):
 5665        return cls(
 5666            bind_interface=d.get('bind_interface'),
 5667            certificate_authority=d.get('certificate_authority'),
 5668            egress_filter=d.get('egress_filter'),
 5669            endpoint=d.get('endpoint'),
 5670            healthcheck_namespace=d.get('healthcheck_namespace'),
 5671            healthy=d.get('healthy'),
 5672            id=d.get('id'),
 5673            name=d.get('name'),
 5674            secret_store_id=d.get('secret_store_id'),
 5675            service_account_key=d.get('service_account_key'),
 5676            tags=d.get('tags'),
 5677        )
 5678
 5679
 5680class Greenplum:
 5681    '''
 5682
 5683    '''
 5684    __slots__ = [
 5685        'bind_interface',
 5686        'database',
 5687        'egress_filter',
 5688        'healthy',
 5689        'hostname',
 5690        'id',
 5691        'name',
 5692        'override_database',
 5693        'password',
 5694        'port',
 5695        'port_override',
 5696        'secret_store_id',
 5697        'tags',
 5698        'username',
 5699    ]
 5700
 5701    def __init__(
 5702        self,
 5703        bind_interface=None,
 5704        database=None,
 5705        egress_filter=None,
 5706        healthy=None,
 5707        hostname=None,
 5708        id=None,
 5709        name=None,
 5710        override_database=None,
 5711        password=None,
 5712        port=None,
 5713        port_override=None,
 5714        secret_store_id=None,
 5715        tags=None,
 5716        username=None,
 5717    ):
 5718        self.bind_interface = bind_interface if bind_interface is not None else ''
 5719        '''
 5720         Bind interface
 5721        '''
 5722        self.database = database if database is not None else ''
 5723        '''
 5724
 5725        '''
 5726        self.egress_filter = egress_filter if egress_filter is not None else ''
 5727        '''
 5728         A filter applied to the routing logic to pin datasource to nodes.
 5729        '''
 5730        self.healthy = healthy if healthy is not None else False
 5731        '''
 5732         True if the datasource is reachable and the credentials are valid.
 5733        '''
 5734        self.hostname = hostname if hostname is not None else ''
 5735        '''
 5736
 5737        '''
 5738        self.id = id if id is not None else ''
 5739        '''
 5740         Unique identifier of the Resource.
 5741        '''
 5742        self.name = name if name is not None else ''
 5743        '''
 5744         Unique human-readable name of the Resource.
 5745        '''
 5746        self.override_database = override_database if override_database is not None else False
 5747        '''
 5748
 5749        '''
 5750        self.password = password if password is not None else ''
 5751        '''
 5752
 5753        '''
 5754        self.port = port if port is not None else 0
 5755        '''
 5756
 5757        '''
 5758        self.port_override = port_override if port_override is not None else 0
 5759        '''
 5760
 5761        '''
 5762        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5763        '''
 5764         ID of the secret store containing credentials for this resource, if any.
 5765        '''
 5766        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5767        '''
 5768         Tags is a map of key, value pairs.
 5769        '''
 5770        self.username = username if username is not None else ''
 5771        '''
 5772
 5773        '''
 5774
 5775    def __repr__(self):
 5776        return '<sdm.Greenplum ' + \
 5777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5778            'database: ' + repr(self.database) + ' ' +\
 5779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5780            'healthy: ' + repr(self.healthy) + ' ' +\
 5781            'hostname: ' + repr(self.hostname) + ' ' +\
 5782            'id: ' + repr(self.id) + ' ' +\
 5783            'name: ' + repr(self.name) + ' ' +\
 5784            'override_database: ' + repr(self.override_database) + ' ' +\
 5785            'password: ' + repr(self.password) + ' ' +\
 5786            'port: ' + repr(self.port) + ' ' +\
 5787            'port_override: ' + repr(self.port_override) + ' ' +\
 5788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5789            'tags: ' + repr(self.tags) + ' ' +\
 5790            'username: ' + repr(self.username) + ' ' +\
 5791            '>'
 5792
 5793    def to_dict(self):
 5794        return {
 5795            'bind_interface': self.bind_interface,
 5796            'database': self.database,
 5797            'egress_filter': self.egress_filter,
 5798            'healthy': self.healthy,
 5799            'hostname': self.hostname,
 5800            'id': self.id,
 5801            'name': self.name,
 5802            'override_database': self.override_database,
 5803            'password': self.password,
 5804            'port': self.port,
 5805            'port_override': self.port_override,
 5806            'secret_store_id': self.secret_store_id,
 5807            'tags': self.tags,
 5808            'username': self.username,
 5809        }
 5810
 5811    @classmethod
 5812    def from_dict(cls, d):
 5813        return cls(
 5814            bind_interface=d.get('bind_interface'),
 5815            database=d.get('database'),
 5816            egress_filter=d.get('egress_filter'),
 5817            healthy=d.get('healthy'),
 5818            hostname=d.get('hostname'),
 5819            id=d.get('id'),
 5820            name=d.get('name'),
 5821            override_database=d.get('override_database'),
 5822            password=d.get('password'),
 5823            port=d.get('port'),
 5824            port_override=d.get('port_override'),
 5825            secret_store_id=d.get('secret_store_id'),
 5826            tags=d.get('tags'),
 5827            username=d.get('username'),
 5828        )
 5829
 5830
 5831class HTTPAuth:
 5832    '''
 5833
 5834    '''
 5835    __slots__ = [
 5836        'auth_header',
 5837        'bind_interface',
 5838        'default_path',
 5839        'egress_filter',
 5840        'headers_blacklist',
 5841        'healthcheck_path',
 5842        'healthy',
 5843        'id',
 5844        'name',
 5845        'secret_store_id',
 5846        'subdomain',
 5847        'tags',
 5848        'url',
 5849    ]
 5850
 5851    def __init__(
 5852        self,
 5853        auth_header=None,
 5854        bind_interface=None,
 5855        default_path=None,
 5856        egress_filter=None,
 5857        headers_blacklist=None,
 5858        healthcheck_path=None,
 5859        healthy=None,
 5860        id=None,
 5861        name=None,
 5862        secret_store_id=None,
 5863        subdomain=None,
 5864        tags=None,
 5865        url=None,
 5866    ):
 5867        self.auth_header = auth_header if auth_header is not None else ''
 5868        '''
 5869
 5870        '''
 5871        self.bind_interface = bind_interface if bind_interface is not None else ''
 5872        '''
 5873         Bind interface
 5874        '''
 5875        self.default_path = default_path if default_path is not None else ''
 5876        '''
 5877
 5878        '''
 5879        self.egress_filter = egress_filter if egress_filter is not None else ''
 5880        '''
 5881         A filter applied to the routing logic to pin datasource to nodes.
 5882        '''
 5883        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5884        '''
 5885
 5886        '''
 5887        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5888        '''
 5889
 5890        '''
 5891        self.healthy = healthy if healthy is not None else False
 5892        '''
 5893         True if the datasource is reachable and the credentials are valid.
 5894        '''
 5895        self.id = id if id is not None else ''
 5896        '''
 5897         Unique identifier of the Resource.
 5898        '''
 5899        self.name = name if name is not None else ''
 5900        '''
 5901         Unique human-readable name of the Resource.
 5902        '''
 5903        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5904        '''
 5905         ID of the secret store containing credentials for this resource, if any.
 5906        '''
 5907        self.subdomain = subdomain if subdomain is not None else ''
 5908        '''
 5909
 5910        '''
 5911        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5912        '''
 5913         Tags is a map of key, value pairs.
 5914        '''
 5915        self.url = url if url is not None else ''
 5916        '''
 5917
 5918        '''
 5919
 5920    def __repr__(self):
 5921        return '<sdm.HTTPAuth ' + \
 5922            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5924            'default_path: ' + repr(self.default_path) + ' ' +\
 5925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5926            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5927            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5928            'healthy: ' + repr(self.healthy) + ' ' +\
 5929            'id: ' + repr(self.id) + ' ' +\
 5930            'name: ' + repr(self.name) + ' ' +\
 5931            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5932            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5933            'tags: ' + repr(self.tags) + ' ' +\
 5934            'url: ' + repr(self.url) + ' ' +\
 5935            '>'
 5936
 5937    def to_dict(self):
 5938        return {
 5939            'auth_header': self.auth_header,
 5940            'bind_interface': self.bind_interface,
 5941            'default_path': self.default_path,
 5942            'egress_filter': self.egress_filter,
 5943            'headers_blacklist': self.headers_blacklist,
 5944            'healthcheck_path': self.healthcheck_path,
 5945            'healthy': self.healthy,
 5946            'id': self.id,
 5947            'name': self.name,
 5948            'secret_store_id': self.secret_store_id,
 5949            'subdomain': self.subdomain,
 5950            'tags': self.tags,
 5951            'url': self.url,
 5952        }
 5953
 5954    @classmethod
 5955    def from_dict(cls, d):
 5956        return cls(
 5957            auth_header=d.get('auth_header'),
 5958            bind_interface=d.get('bind_interface'),
 5959            default_path=d.get('default_path'),
 5960            egress_filter=d.get('egress_filter'),
 5961            headers_blacklist=d.get('headers_blacklist'),
 5962            healthcheck_path=d.get('healthcheck_path'),
 5963            healthy=d.get('healthy'),
 5964            id=d.get('id'),
 5965            name=d.get('name'),
 5966            secret_store_id=d.get('secret_store_id'),
 5967            subdomain=d.get('subdomain'),
 5968            tags=d.get('tags'),
 5969            url=d.get('url'),
 5970        )
 5971
 5972
 5973class HTTPBasicAuth:
 5974    '''
 5975
 5976    '''
 5977    __slots__ = [
 5978        'bind_interface',
 5979        'default_path',
 5980        'egress_filter',
 5981        'headers_blacklist',
 5982        'healthcheck_path',
 5983        'healthy',
 5984        'id',
 5985        'name',
 5986        'password',
 5987        'secret_store_id',
 5988        'subdomain',
 5989        'tags',
 5990        'url',
 5991        'username',
 5992    ]
 5993
 5994    def __init__(
 5995        self,
 5996        bind_interface=None,
 5997        default_path=None,
 5998        egress_filter=None,
 5999        headers_blacklist=None,
 6000        healthcheck_path=None,
 6001        healthy=None,
 6002        id=None,
 6003        name=None,
 6004        password=None,
 6005        secret_store_id=None,
 6006        subdomain=None,
 6007        tags=None,
 6008        url=None,
 6009        username=None,
 6010    ):
 6011        self.bind_interface = bind_interface if bind_interface is not None else ''
 6012        '''
 6013         Bind interface
 6014        '''
 6015        self.default_path = default_path if default_path is not None else ''
 6016        '''
 6017
 6018        '''
 6019        self.egress_filter = egress_filter if egress_filter is not None else ''
 6020        '''
 6021         A filter applied to the routing logic to pin datasource to nodes.
 6022        '''
 6023        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6024        '''
 6025
 6026        '''
 6027        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6028        '''
 6029
 6030        '''
 6031        self.healthy = healthy if healthy is not None else False
 6032        '''
 6033         True if the datasource is reachable and the credentials are valid.
 6034        '''
 6035        self.id = id if id is not None else ''
 6036        '''
 6037         Unique identifier of the Resource.
 6038        '''
 6039        self.name = name if name is not None else ''
 6040        '''
 6041         Unique human-readable name of the Resource.
 6042        '''
 6043        self.password = password if password is not None else ''
 6044        '''
 6045
 6046        '''
 6047        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6048        '''
 6049         ID of the secret store containing credentials for this resource, if any.
 6050        '''
 6051        self.subdomain = subdomain if subdomain is not None else ''
 6052        '''
 6053
 6054        '''
 6055        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6056        '''
 6057         Tags is a map of key, value pairs.
 6058        '''
 6059        self.url = url if url is not None else ''
 6060        '''
 6061
 6062        '''
 6063        self.username = username if username is not None else ''
 6064        '''
 6065
 6066        '''
 6067
 6068    def __repr__(self):
 6069        return '<sdm.HTTPBasicAuth ' + \
 6070            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6071            'default_path: ' + repr(self.default_path) + ' ' +\
 6072            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6073            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6074            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6075            'healthy: ' + repr(self.healthy) + ' ' +\
 6076            'id: ' + repr(self.id) + ' ' +\
 6077            'name: ' + repr(self.name) + ' ' +\
 6078            'password: ' + repr(self.password) + ' ' +\
 6079            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6080            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6081            'tags: ' + repr(self.tags) + ' ' +\
 6082            'url: ' + repr(self.url) + ' ' +\
 6083            'username: ' + repr(self.username) + ' ' +\
 6084            '>'
 6085
 6086    def to_dict(self):
 6087        return {
 6088            'bind_interface': self.bind_interface,
 6089            'default_path': self.default_path,
 6090            'egress_filter': self.egress_filter,
 6091            'headers_blacklist': self.headers_blacklist,
 6092            'healthcheck_path': self.healthcheck_path,
 6093            'healthy': self.healthy,
 6094            'id': self.id,
 6095            'name': self.name,
 6096            'password': self.password,
 6097            'secret_store_id': self.secret_store_id,
 6098            'subdomain': self.subdomain,
 6099            'tags': self.tags,
 6100            'url': self.url,
 6101            'username': self.username,
 6102        }
 6103
 6104    @classmethod
 6105    def from_dict(cls, d):
 6106        return cls(
 6107            bind_interface=d.get('bind_interface'),
 6108            default_path=d.get('default_path'),
 6109            egress_filter=d.get('egress_filter'),
 6110            headers_blacklist=d.get('headers_blacklist'),
 6111            healthcheck_path=d.get('healthcheck_path'),
 6112            healthy=d.get('healthy'),
 6113            id=d.get('id'),
 6114            name=d.get('name'),
 6115            password=d.get('password'),
 6116            secret_store_id=d.get('secret_store_id'),
 6117            subdomain=d.get('subdomain'),
 6118            tags=d.get('tags'),
 6119            url=d.get('url'),
 6120            username=d.get('username'),
 6121        )
 6122
 6123
 6124class HTTPNoAuth:
 6125    '''
 6126
 6127    '''
 6128    __slots__ = [
 6129        'bind_interface',
 6130        'default_path',
 6131        'egress_filter',
 6132        'headers_blacklist',
 6133        'healthcheck_path',
 6134        'healthy',
 6135        'id',
 6136        'name',
 6137        'secret_store_id',
 6138        'subdomain',
 6139        'tags',
 6140        'url',
 6141    ]
 6142
 6143    def __init__(
 6144        self,
 6145        bind_interface=None,
 6146        default_path=None,
 6147        egress_filter=None,
 6148        headers_blacklist=None,
 6149        healthcheck_path=None,
 6150        healthy=None,
 6151        id=None,
 6152        name=None,
 6153        secret_store_id=None,
 6154        subdomain=None,
 6155        tags=None,
 6156        url=None,
 6157    ):
 6158        self.bind_interface = bind_interface if bind_interface is not None else ''
 6159        '''
 6160         Bind interface
 6161        '''
 6162        self.default_path = default_path if default_path is not None else ''
 6163        '''
 6164
 6165        '''
 6166        self.egress_filter = egress_filter if egress_filter is not None else ''
 6167        '''
 6168         A filter applied to the routing logic to pin datasource to nodes.
 6169        '''
 6170        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6171        '''
 6172
 6173        '''
 6174        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6175        '''
 6176
 6177        '''
 6178        self.healthy = healthy if healthy is not None else False
 6179        '''
 6180         True if the datasource is reachable and the credentials are valid.
 6181        '''
 6182        self.id = id if id is not None else ''
 6183        '''
 6184         Unique identifier of the Resource.
 6185        '''
 6186        self.name = name if name is not None else ''
 6187        '''
 6188         Unique human-readable name of the Resource.
 6189        '''
 6190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6191        '''
 6192         ID of the secret store containing credentials for this resource, if any.
 6193        '''
 6194        self.subdomain = subdomain if subdomain is not None else ''
 6195        '''
 6196
 6197        '''
 6198        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6199        '''
 6200         Tags is a map of key, value pairs.
 6201        '''
 6202        self.url = url if url is not None else ''
 6203        '''
 6204
 6205        '''
 6206
 6207    def __repr__(self):
 6208        return '<sdm.HTTPNoAuth ' + \
 6209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6210            'default_path: ' + repr(self.default_path) + ' ' +\
 6211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6212            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6213            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6214            'healthy: ' + repr(self.healthy) + ' ' +\
 6215            'id: ' + repr(self.id) + ' ' +\
 6216            'name: ' + repr(self.name) + ' ' +\
 6217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6218            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6219            'tags: ' + repr(self.tags) + ' ' +\
 6220            'url: ' + repr(self.url) + ' ' +\
 6221            '>'
 6222
 6223    def to_dict(self):
 6224        return {
 6225            'bind_interface': self.bind_interface,
 6226            'default_path': self.default_path,
 6227            'egress_filter': self.egress_filter,
 6228            'headers_blacklist': self.headers_blacklist,
 6229            'healthcheck_path': self.healthcheck_path,
 6230            'healthy': self.healthy,
 6231            'id': self.id,
 6232            'name': self.name,
 6233            'secret_store_id': self.secret_store_id,
 6234            'subdomain': self.subdomain,
 6235            'tags': self.tags,
 6236            'url': self.url,
 6237        }
 6238
 6239    @classmethod
 6240    def from_dict(cls, d):
 6241        return cls(
 6242            bind_interface=d.get('bind_interface'),
 6243            default_path=d.get('default_path'),
 6244            egress_filter=d.get('egress_filter'),
 6245            headers_blacklist=d.get('headers_blacklist'),
 6246            healthcheck_path=d.get('healthcheck_path'),
 6247            healthy=d.get('healthy'),
 6248            id=d.get('id'),
 6249            name=d.get('name'),
 6250            secret_store_id=d.get('secret_store_id'),
 6251            subdomain=d.get('subdomain'),
 6252            tags=d.get('tags'),
 6253            url=d.get('url'),
 6254        )
 6255
 6256
 6257class Kubernetes:
 6258    '''
 6259
 6260    '''
 6261    __slots__ = [
 6262        'bind_interface',
 6263        'certificate_authority',
 6264        'client_certificate',
 6265        'client_key',
 6266        'egress_filter',
 6267        'healthcheck_namespace',
 6268        'healthy',
 6269        'hostname',
 6270        'id',
 6271        'name',
 6272        'port',
 6273        'port_override',
 6274        'remote_identity_group_id',
 6275        'remote_identity_healthcheck_username',
 6276        'secret_store_id',
 6277        'tags',
 6278    ]
 6279
 6280    def __init__(
 6281        self,
 6282        bind_interface=None,
 6283        certificate_authority=None,
 6284        client_certificate=None,
 6285        client_key=None,
 6286        egress_filter=None,
 6287        healthcheck_namespace=None,
 6288        healthy=None,
 6289        hostname=None,
 6290        id=None,
 6291        name=None,
 6292        port=None,
 6293        port_override=None,
 6294        remote_identity_group_id=None,
 6295        remote_identity_healthcheck_username=None,
 6296        secret_store_id=None,
 6297        tags=None,
 6298    ):
 6299        self.bind_interface = bind_interface if bind_interface is not None else ''
 6300        '''
 6301         Bind interface
 6302        '''
 6303        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6304        '''
 6305
 6306        '''
 6307        self.client_certificate = client_certificate if client_certificate is not None else ''
 6308        '''
 6309
 6310        '''
 6311        self.client_key = client_key if client_key is not None else ''
 6312        '''
 6313
 6314        '''
 6315        self.egress_filter = egress_filter if egress_filter is not None else ''
 6316        '''
 6317         A filter applied to the routing logic to pin datasource to nodes.
 6318        '''
 6319        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6320        '''
 6321         The path used to check the health of your connection.  Defaults to `default`.
 6322        '''
 6323        self.healthy = healthy if healthy is not None else False
 6324        '''
 6325         True if the datasource is reachable and the credentials are valid.
 6326        '''
 6327        self.hostname = hostname if hostname is not None else ''
 6328        '''
 6329
 6330        '''
 6331        self.id = id if id is not None else ''
 6332        '''
 6333         Unique identifier of the Resource.
 6334        '''
 6335        self.name = name if name is not None else ''
 6336        '''
 6337         Unique human-readable name of the Resource.
 6338        '''
 6339        self.port = port if port is not None else 0
 6340        '''
 6341
 6342        '''
 6343        self.port_override = port_override if port_override is not None else 0
 6344        '''
 6345
 6346        '''
 6347        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6348        '''
 6349
 6350        '''
 6351        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6352        '''
 6353
 6354        '''
 6355        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6356        '''
 6357         ID of the secret store containing credentials for this resource, if any.
 6358        '''
 6359        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6360        '''
 6361         Tags is a map of key, value pairs.
 6362        '''
 6363
 6364    def __repr__(self):
 6365        return '<sdm.Kubernetes ' + \
 6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6367            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6368            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6369            'client_key: ' + repr(self.client_key) + ' ' +\
 6370            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6371            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6372            'healthy: ' + repr(self.healthy) + ' ' +\
 6373            'hostname: ' + repr(self.hostname) + ' ' +\
 6374            'id: ' + repr(self.id) + ' ' +\
 6375            'name: ' + repr(self.name) + ' ' +\
 6376            'port: ' + repr(self.port) + ' ' +\
 6377            'port_override: ' + repr(self.port_override) + ' ' +\
 6378            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6379            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6380            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6381            'tags: ' + repr(self.tags) + ' ' +\
 6382            '>'
 6383
 6384    def to_dict(self):
 6385        return {
 6386            'bind_interface': self.bind_interface,
 6387            'certificate_authority': self.certificate_authority,
 6388            'client_certificate': self.client_certificate,
 6389            'client_key': self.client_key,
 6390            'egress_filter': self.egress_filter,
 6391            'healthcheck_namespace': self.healthcheck_namespace,
 6392            'healthy': self.healthy,
 6393            'hostname': self.hostname,
 6394            'id': self.id,
 6395            'name': self.name,
 6396            'port': self.port,
 6397            'port_override': self.port_override,
 6398            'remote_identity_group_id': self.remote_identity_group_id,
 6399            'remote_identity_healthcheck_username':
 6400            self.remote_identity_healthcheck_username,
 6401            'secret_store_id': self.secret_store_id,
 6402            'tags': self.tags,
 6403        }
 6404
 6405    @classmethod
 6406    def from_dict(cls, d):
 6407        return cls(
 6408            bind_interface=d.get('bind_interface'),
 6409            certificate_authority=d.get('certificate_authority'),
 6410            client_certificate=d.get('client_certificate'),
 6411            client_key=d.get('client_key'),
 6412            egress_filter=d.get('egress_filter'),
 6413            healthcheck_namespace=d.get('healthcheck_namespace'),
 6414            healthy=d.get('healthy'),
 6415            hostname=d.get('hostname'),
 6416            id=d.get('id'),
 6417            name=d.get('name'),
 6418            port=d.get('port'),
 6419            port_override=d.get('port_override'),
 6420            remote_identity_group_id=d.get('remote_identity_group_id'),
 6421            remote_identity_healthcheck_username=d.get(
 6422                'remote_identity_healthcheck_username'),
 6423            secret_store_id=d.get('secret_store_id'),
 6424            tags=d.get('tags'),
 6425        )
 6426
 6427
 6428class KubernetesBasicAuth:
 6429    '''
 6430
 6431    '''
 6432    __slots__ = [
 6433        'bind_interface',
 6434        'egress_filter',
 6435        'healthcheck_namespace',
 6436        'healthy',
 6437        'hostname',
 6438        'id',
 6439        'name',
 6440        'password',
 6441        'port',
 6442        'port_override',
 6443        'secret_store_id',
 6444        'tags',
 6445        'username',
 6446    ]
 6447
 6448    def __init__(
 6449        self,
 6450        bind_interface=None,
 6451        egress_filter=None,
 6452        healthcheck_namespace=None,
 6453        healthy=None,
 6454        hostname=None,
 6455        id=None,
 6456        name=None,
 6457        password=None,
 6458        port=None,
 6459        port_override=None,
 6460        secret_store_id=None,
 6461        tags=None,
 6462        username=None,
 6463    ):
 6464        self.bind_interface = bind_interface if bind_interface is not None else ''
 6465        '''
 6466         Bind interface
 6467        '''
 6468        self.egress_filter = egress_filter if egress_filter is not None else ''
 6469        '''
 6470         A filter applied to the routing logic to pin datasource to nodes.
 6471        '''
 6472        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6473        '''
 6474         The path used to check the health of your connection.  Defaults to `default`.
 6475        '''
 6476        self.healthy = healthy if healthy is not None else False
 6477        '''
 6478         True if the datasource is reachable and the credentials are valid.
 6479        '''
 6480        self.hostname = hostname if hostname is not None else ''
 6481        '''
 6482
 6483        '''
 6484        self.id = id if id is not None else ''
 6485        '''
 6486         Unique identifier of the Resource.
 6487        '''
 6488        self.name = name if name is not None else ''
 6489        '''
 6490         Unique human-readable name of the Resource.
 6491        '''
 6492        self.password = password if password is not None else ''
 6493        '''
 6494
 6495        '''
 6496        self.port = port if port is not None else 0
 6497        '''
 6498
 6499        '''
 6500        self.port_override = port_override if port_override is not None else 0
 6501        '''
 6502
 6503        '''
 6504        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6505        '''
 6506         ID of the secret store containing credentials for this resource, if any.
 6507        '''
 6508        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6509        '''
 6510         Tags is a map of key, value pairs.
 6511        '''
 6512        self.username = username if username is not None else ''
 6513        '''
 6514
 6515        '''
 6516
 6517    def __repr__(self):
 6518        return '<sdm.KubernetesBasicAuth ' + \
 6519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6521            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6522            'healthy: ' + repr(self.healthy) + ' ' +\
 6523            'hostname: ' + repr(self.hostname) + ' ' +\
 6524            'id: ' + repr(self.id) + ' ' +\
 6525            'name: ' + repr(self.name) + ' ' +\
 6526            'password: ' + repr(self.password) + ' ' +\
 6527            'port: ' + repr(self.port) + ' ' +\
 6528            'port_override: ' + repr(self.port_override) + ' ' +\
 6529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6530            'tags: ' + repr(self.tags) + ' ' +\
 6531            'username: ' + repr(self.username) + ' ' +\
 6532            '>'
 6533
 6534    def to_dict(self):
 6535        return {
 6536            'bind_interface': self.bind_interface,
 6537            'egress_filter': self.egress_filter,
 6538            'healthcheck_namespace': self.healthcheck_namespace,
 6539            'healthy': self.healthy,
 6540            'hostname': self.hostname,
 6541            'id': self.id,
 6542            'name': self.name,
 6543            'password': self.password,
 6544            'port': self.port,
 6545            'port_override': self.port_override,
 6546            'secret_store_id': self.secret_store_id,
 6547            'tags': self.tags,
 6548            'username': self.username,
 6549        }
 6550
 6551    @classmethod
 6552    def from_dict(cls, d):
 6553        return cls(
 6554            bind_interface=d.get('bind_interface'),
 6555            egress_filter=d.get('egress_filter'),
 6556            healthcheck_namespace=d.get('healthcheck_namespace'),
 6557            healthy=d.get('healthy'),
 6558            hostname=d.get('hostname'),
 6559            id=d.get('id'),
 6560            name=d.get('name'),
 6561            password=d.get('password'),
 6562            port=d.get('port'),
 6563            port_override=d.get('port_override'),
 6564            secret_store_id=d.get('secret_store_id'),
 6565            tags=d.get('tags'),
 6566            username=d.get('username'),
 6567        )
 6568
 6569
 6570class KubernetesServiceAccount:
 6571    '''
 6572
 6573    '''
 6574    __slots__ = [
 6575        'bind_interface',
 6576        'egress_filter',
 6577        'healthcheck_namespace',
 6578        'healthy',
 6579        'hostname',
 6580        'id',
 6581        'name',
 6582        'port',
 6583        'port_override',
 6584        'remote_identity_group_id',
 6585        'remote_identity_healthcheck_username',
 6586        'secret_store_id',
 6587        'tags',
 6588        'token',
 6589    ]
 6590
 6591    def __init__(
 6592        self,
 6593        bind_interface=None,
 6594        egress_filter=None,
 6595        healthcheck_namespace=None,
 6596        healthy=None,
 6597        hostname=None,
 6598        id=None,
 6599        name=None,
 6600        port=None,
 6601        port_override=None,
 6602        remote_identity_group_id=None,
 6603        remote_identity_healthcheck_username=None,
 6604        secret_store_id=None,
 6605        tags=None,
 6606        token=None,
 6607    ):
 6608        self.bind_interface = bind_interface if bind_interface is not None else ''
 6609        '''
 6610         Bind interface
 6611        '''
 6612        self.egress_filter = egress_filter if egress_filter is not None else ''
 6613        '''
 6614         A filter applied to the routing logic to pin datasource to nodes.
 6615        '''
 6616        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6617        '''
 6618         The path used to check the health of your connection.  Defaults to `default`.
 6619        '''
 6620        self.healthy = healthy if healthy is not None else False
 6621        '''
 6622         True if the datasource is reachable and the credentials are valid.
 6623        '''
 6624        self.hostname = hostname if hostname is not None else ''
 6625        '''
 6626
 6627        '''
 6628        self.id = id if id is not None else ''
 6629        '''
 6630         Unique identifier of the Resource.
 6631        '''
 6632        self.name = name if name is not None else ''
 6633        '''
 6634         Unique human-readable name of the Resource.
 6635        '''
 6636        self.port = port if port is not None else 0
 6637        '''
 6638
 6639        '''
 6640        self.port_override = port_override if port_override is not None else 0
 6641        '''
 6642
 6643        '''
 6644        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6645        '''
 6646
 6647        '''
 6648        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6649        '''
 6650
 6651        '''
 6652        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6653        '''
 6654         ID of the secret store containing credentials for this resource, if any.
 6655        '''
 6656        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6657        '''
 6658         Tags is a map of key, value pairs.
 6659        '''
 6660        self.token = token if token is not None else ''
 6661        '''
 6662
 6663        '''
 6664
 6665    def __repr__(self):
 6666        return '<sdm.KubernetesServiceAccount ' + \
 6667            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6669            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6670            'healthy: ' + repr(self.healthy) + ' ' +\
 6671            'hostname: ' + repr(self.hostname) + ' ' +\
 6672            'id: ' + repr(self.id) + ' ' +\
 6673            'name: ' + repr(self.name) + ' ' +\
 6674            'port: ' + repr(self.port) + ' ' +\
 6675            'port_override: ' + repr(self.port_override) + ' ' +\
 6676            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6677            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6678            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6679            'tags: ' + repr(self.tags) + ' ' +\
 6680            'token: ' + repr(self.token) + ' ' +\
 6681            '>'
 6682
 6683    def to_dict(self):
 6684        return {
 6685            'bind_interface': self.bind_interface,
 6686            'egress_filter': self.egress_filter,
 6687            'healthcheck_namespace': self.healthcheck_namespace,
 6688            'healthy': self.healthy,
 6689            'hostname': self.hostname,
 6690            'id': self.id,
 6691            'name': self.name,
 6692            'port': self.port,
 6693            'port_override': self.port_override,
 6694            'remote_identity_group_id': self.remote_identity_group_id,
 6695            'remote_identity_healthcheck_username':
 6696            self.remote_identity_healthcheck_username,
 6697            'secret_store_id': self.secret_store_id,
 6698            'tags': self.tags,
 6699            'token': self.token,
 6700        }
 6701
 6702    @classmethod
 6703    def from_dict(cls, d):
 6704        return cls(
 6705            bind_interface=d.get('bind_interface'),
 6706            egress_filter=d.get('egress_filter'),
 6707            healthcheck_namespace=d.get('healthcheck_namespace'),
 6708            healthy=d.get('healthy'),
 6709            hostname=d.get('hostname'),
 6710            id=d.get('id'),
 6711            name=d.get('name'),
 6712            port=d.get('port'),
 6713            port_override=d.get('port_override'),
 6714            remote_identity_group_id=d.get('remote_identity_group_id'),
 6715            remote_identity_healthcheck_username=d.get(
 6716                'remote_identity_healthcheck_username'),
 6717            secret_store_id=d.get('secret_store_id'),
 6718            tags=d.get('tags'),
 6719            token=d.get('token'),
 6720        )
 6721
 6722
 6723class KubernetesServiceAccountUserImpersonation:
 6724    '''
 6725
 6726    '''
 6727    __slots__ = [
 6728        'bind_interface',
 6729        'egress_filter',
 6730        'healthcheck_namespace',
 6731        'healthy',
 6732        'hostname',
 6733        'id',
 6734        'name',
 6735        'port',
 6736        'port_override',
 6737        'secret_store_id',
 6738        'tags',
 6739        'token',
 6740    ]
 6741
 6742    def __init__(
 6743        self,
 6744        bind_interface=None,
 6745        egress_filter=None,
 6746        healthcheck_namespace=None,
 6747        healthy=None,
 6748        hostname=None,
 6749        id=None,
 6750        name=None,
 6751        port=None,
 6752        port_override=None,
 6753        secret_store_id=None,
 6754        tags=None,
 6755        token=None,
 6756    ):
 6757        self.bind_interface = bind_interface if bind_interface is not None else ''
 6758        '''
 6759         Bind interface
 6760        '''
 6761        self.egress_filter = egress_filter if egress_filter is not None else ''
 6762        '''
 6763         A filter applied to the routing logic to pin datasource to nodes.
 6764        '''
 6765        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6766        '''
 6767         The path used to check the health of your connection.  Defaults to `default`.
 6768        '''
 6769        self.healthy = healthy if healthy is not None else False
 6770        '''
 6771         True if the datasource is reachable and the credentials are valid.
 6772        '''
 6773        self.hostname = hostname if hostname is not None else ''
 6774        '''
 6775
 6776        '''
 6777        self.id = id if id is not None else ''
 6778        '''
 6779         Unique identifier of the Resource.
 6780        '''
 6781        self.name = name if name is not None else ''
 6782        '''
 6783         Unique human-readable name of the Resource.
 6784        '''
 6785        self.port = port if port is not None else 0
 6786        '''
 6787
 6788        '''
 6789        self.port_override = port_override if port_override is not None else 0
 6790        '''
 6791
 6792        '''
 6793        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6794        '''
 6795         ID of the secret store containing credentials for this resource, if any.
 6796        '''
 6797        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6798        '''
 6799         Tags is a map of key, value pairs.
 6800        '''
 6801        self.token = token if token is not None else ''
 6802        '''
 6803
 6804        '''
 6805
 6806    def __repr__(self):
 6807        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6808            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6809            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6810            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6811            'healthy: ' + repr(self.healthy) + ' ' +\
 6812            'hostname: ' + repr(self.hostname) + ' ' +\
 6813            'id: ' + repr(self.id) + ' ' +\
 6814            'name: ' + repr(self.name) + ' ' +\
 6815            'port: ' + repr(self.port) + ' ' +\
 6816            'port_override: ' + repr(self.port_override) + ' ' +\
 6817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6818            'tags: ' + repr(self.tags) + ' ' +\
 6819            'token: ' + repr(self.token) + ' ' +\
 6820            '>'
 6821
 6822    def to_dict(self):
 6823        return {
 6824            'bind_interface': self.bind_interface,
 6825            'egress_filter': self.egress_filter,
 6826            'healthcheck_namespace': self.healthcheck_namespace,
 6827            'healthy': self.healthy,
 6828            'hostname': self.hostname,
 6829            'id': self.id,
 6830            'name': self.name,
 6831            'port': self.port,
 6832            'port_override': self.port_override,
 6833            'secret_store_id': self.secret_store_id,
 6834            'tags': self.tags,
 6835            'token': self.token,
 6836        }
 6837
 6838    @classmethod
 6839    def from_dict(cls, d):
 6840        return cls(
 6841            bind_interface=d.get('bind_interface'),
 6842            egress_filter=d.get('egress_filter'),
 6843            healthcheck_namespace=d.get('healthcheck_namespace'),
 6844            healthy=d.get('healthy'),
 6845            hostname=d.get('hostname'),
 6846            id=d.get('id'),
 6847            name=d.get('name'),
 6848            port=d.get('port'),
 6849            port_override=d.get('port_override'),
 6850            secret_store_id=d.get('secret_store_id'),
 6851            tags=d.get('tags'),
 6852            token=d.get('token'),
 6853        )
 6854
 6855
 6856class KubernetesUserImpersonation:
 6857    '''
 6858
 6859    '''
 6860    __slots__ = [
 6861        'bind_interface',
 6862        'certificate_authority',
 6863        'client_certificate',
 6864        'client_key',
 6865        'egress_filter',
 6866        'healthcheck_namespace',
 6867        'healthy',
 6868        'hostname',
 6869        'id',
 6870        'name',
 6871        'port',
 6872        'port_override',
 6873        'secret_store_id',
 6874        'tags',
 6875    ]
 6876
 6877    def __init__(
 6878        self,
 6879        bind_interface=None,
 6880        certificate_authority=None,
 6881        client_certificate=None,
 6882        client_key=None,
 6883        egress_filter=None,
 6884        healthcheck_namespace=None,
 6885        healthy=None,
 6886        hostname=None,
 6887        id=None,
 6888        name=None,
 6889        port=None,
 6890        port_override=None,
 6891        secret_store_id=None,
 6892        tags=None,
 6893    ):
 6894        self.bind_interface = bind_interface if bind_interface is not None else ''
 6895        '''
 6896         Bind interface
 6897        '''
 6898        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6899        '''
 6900
 6901        '''
 6902        self.client_certificate = client_certificate if client_certificate is not None else ''
 6903        '''
 6904
 6905        '''
 6906        self.client_key = client_key if client_key is not None else ''
 6907        '''
 6908
 6909        '''
 6910        self.egress_filter = egress_filter if egress_filter is not None else ''
 6911        '''
 6912         A filter applied to the routing logic to pin datasource to nodes.
 6913        '''
 6914        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6915        '''
 6916         The path used to check the health of your connection.  Defaults to `default`.
 6917        '''
 6918        self.healthy = healthy if healthy is not None else False
 6919        '''
 6920         True if the datasource is reachable and the credentials are valid.
 6921        '''
 6922        self.hostname = hostname if hostname is not None else ''
 6923        '''
 6924
 6925        '''
 6926        self.id = id if id is not None else ''
 6927        '''
 6928         Unique identifier of the Resource.
 6929        '''
 6930        self.name = name if name is not None else ''
 6931        '''
 6932         Unique human-readable name of the Resource.
 6933        '''
 6934        self.port = port if port is not None else 0
 6935        '''
 6936
 6937        '''
 6938        self.port_override = port_override if port_override is not None else 0
 6939        '''
 6940
 6941        '''
 6942        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6943        '''
 6944         ID of the secret store containing credentials for this resource, if any.
 6945        '''
 6946        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6947        '''
 6948         Tags is a map of key, value pairs.
 6949        '''
 6950
 6951    def __repr__(self):
 6952        return '<sdm.KubernetesUserImpersonation ' + \
 6953            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6954            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6955            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6956            'client_key: ' + repr(self.client_key) + ' ' +\
 6957            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6958            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6959            'healthy: ' + repr(self.healthy) + ' ' +\
 6960            'hostname: ' + repr(self.hostname) + ' ' +\
 6961            'id: ' + repr(self.id) + ' ' +\
 6962            'name: ' + repr(self.name) + ' ' +\
 6963            'port: ' + repr(self.port) + ' ' +\
 6964            'port_override: ' + repr(self.port_override) + ' ' +\
 6965            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6966            'tags: ' + repr(self.tags) + ' ' +\
 6967            '>'
 6968
 6969    def to_dict(self):
 6970        return {
 6971            'bind_interface': self.bind_interface,
 6972            'certificate_authority': self.certificate_authority,
 6973            'client_certificate': self.client_certificate,
 6974            'client_key': self.client_key,
 6975            'egress_filter': self.egress_filter,
 6976            'healthcheck_namespace': self.healthcheck_namespace,
 6977            'healthy': self.healthy,
 6978            'hostname': self.hostname,
 6979            'id': self.id,
 6980            'name': self.name,
 6981            'port': self.port,
 6982            'port_override': self.port_override,
 6983            'secret_store_id': self.secret_store_id,
 6984            'tags': self.tags,
 6985        }
 6986
 6987    @classmethod
 6988    def from_dict(cls, d):
 6989        return cls(
 6990            bind_interface=d.get('bind_interface'),
 6991            certificate_authority=d.get('certificate_authority'),
 6992            client_certificate=d.get('client_certificate'),
 6993            client_key=d.get('client_key'),
 6994            egress_filter=d.get('egress_filter'),
 6995            healthcheck_namespace=d.get('healthcheck_namespace'),
 6996            healthy=d.get('healthy'),
 6997            hostname=d.get('hostname'),
 6998            id=d.get('id'),
 6999            name=d.get('name'),
 7000            port=d.get('port'),
 7001            port_override=d.get('port_override'),
 7002            secret_store_id=d.get('secret_store_id'),
 7003            tags=d.get('tags'),
 7004        )
 7005
 7006
 7007class MTLSMysql:
 7008    '''
 7009
 7010    '''
 7011    __slots__ = [
 7012        'bind_interface',
 7013        'certificate_authority',
 7014        'client_certificate',
 7015        'client_key',
 7016        'database',
 7017        'egress_filter',
 7018        'healthy',
 7019        'hostname',
 7020        'id',
 7021        'name',
 7022        'password',
 7023        'port',
 7024        'port_override',
 7025        'secret_store_id',
 7026        'server_name',
 7027        'tags',
 7028        'username',
 7029    ]
 7030
 7031    def __init__(
 7032        self,
 7033        bind_interface=None,
 7034        certificate_authority=None,
 7035        client_certificate=None,
 7036        client_key=None,
 7037        database=None,
 7038        egress_filter=None,
 7039        healthy=None,
 7040        hostname=None,
 7041        id=None,
 7042        name=None,
 7043        password=None,
 7044        port=None,
 7045        port_override=None,
 7046        secret_store_id=None,
 7047        server_name=None,
 7048        tags=None,
 7049        username=None,
 7050    ):
 7051        self.bind_interface = bind_interface if bind_interface is not None else ''
 7052        '''
 7053         Bind interface
 7054        '''
 7055        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7056        '''
 7057
 7058        '''
 7059        self.client_certificate = client_certificate if client_certificate is not None else ''
 7060        '''
 7061
 7062        '''
 7063        self.client_key = client_key if client_key is not None else ''
 7064        '''
 7065
 7066        '''
 7067        self.database = database if database is not None else ''
 7068        '''
 7069
 7070        '''
 7071        self.egress_filter = egress_filter if egress_filter is not None else ''
 7072        '''
 7073         A filter applied to the routing logic to pin datasource to nodes.
 7074        '''
 7075        self.healthy = healthy if healthy is not None else False
 7076        '''
 7077         True if the datasource is reachable and the credentials are valid.
 7078        '''
 7079        self.hostname = hostname if hostname is not None else ''
 7080        '''
 7081
 7082        '''
 7083        self.id = id if id is not None else ''
 7084        '''
 7085         Unique identifier of the Resource.
 7086        '''
 7087        self.name = name if name is not None else ''
 7088        '''
 7089         Unique human-readable name of the Resource.
 7090        '''
 7091        self.password = password if password is not None else ''
 7092        '''
 7093
 7094        '''
 7095        self.port = port if port is not None else 0
 7096        '''
 7097
 7098        '''
 7099        self.port_override = port_override if port_override is not None else 0
 7100        '''
 7101
 7102        '''
 7103        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7104        '''
 7105         ID of the secret store containing credentials for this resource, if any.
 7106        '''
 7107        self.server_name = server_name if server_name is not None else ''
 7108        '''
 7109
 7110        '''
 7111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7112        '''
 7113         Tags is a map of key, value pairs.
 7114        '''
 7115        self.username = username if username is not None else ''
 7116        '''
 7117
 7118        '''
 7119
 7120    def __repr__(self):
 7121        return '<sdm.MTLSMysql ' + \
 7122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7123            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7124            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7125            'client_key: ' + repr(self.client_key) + ' ' +\
 7126            'database: ' + repr(self.database) + ' ' +\
 7127            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7128            'healthy: ' + repr(self.healthy) + ' ' +\
 7129            'hostname: ' + repr(self.hostname) + ' ' +\
 7130            'id: ' + repr(self.id) + ' ' +\
 7131            'name: ' + repr(self.name) + ' ' +\
 7132            'password: ' + repr(self.password) + ' ' +\
 7133            'port: ' + repr(self.port) + ' ' +\
 7134            'port_override: ' + repr(self.port_override) + ' ' +\
 7135            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7136            'server_name: ' + repr(self.server_name) + ' ' +\
 7137            'tags: ' + repr(self.tags) + ' ' +\
 7138            'username: ' + repr(self.username) + ' ' +\
 7139            '>'
 7140
 7141    def to_dict(self):
 7142        return {
 7143            'bind_interface': self.bind_interface,
 7144            'certificate_authority': self.certificate_authority,
 7145            'client_certificate': self.client_certificate,
 7146            'client_key': self.client_key,
 7147            'database': self.database,
 7148            'egress_filter': self.egress_filter,
 7149            'healthy': self.healthy,
 7150            'hostname': self.hostname,
 7151            'id': self.id,
 7152            'name': self.name,
 7153            'password': self.password,
 7154            'port': self.port,
 7155            'port_override': self.port_override,
 7156            'secret_store_id': self.secret_store_id,
 7157            'server_name': self.server_name,
 7158            'tags': self.tags,
 7159            'username': self.username,
 7160        }
 7161
 7162    @classmethod
 7163    def from_dict(cls, d):
 7164        return cls(
 7165            bind_interface=d.get('bind_interface'),
 7166            certificate_authority=d.get('certificate_authority'),
 7167            client_certificate=d.get('client_certificate'),
 7168            client_key=d.get('client_key'),
 7169            database=d.get('database'),
 7170            egress_filter=d.get('egress_filter'),
 7171            healthy=d.get('healthy'),
 7172            hostname=d.get('hostname'),
 7173            id=d.get('id'),
 7174            name=d.get('name'),
 7175            password=d.get('password'),
 7176            port=d.get('port'),
 7177            port_override=d.get('port_override'),
 7178            secret_store_id=d.get('secret_store_id'),
 7179            server_name=d.get('server_name'),
 7180            tags=d.get('tags'),
 7181            username=d.get('username'),
 7182        )
 7183
 7184
 7185class MTLSPostgres:
 7186    '''
 7187
 7188    '''
 7189    __slots__ = [
 7190        'bind_interface',
 7191        'certificate_authority',
 7192        'client_certificate',
 7193        'client_key',
 7194        'database',
 7195        'egress_filter',
 7196        'healthy',
 7197        'hostname',
 7198        'id',
 7199        'name',
 7200        'override_database',
 7201        'password',
 7202        'port',
 7203        'port_override',
 7204        'secret_store_id',
 7205        'server_name',
 7206        'tags',
 7207        'username',
 7208    ]
 7209
 7210    def __init__(
 7211        self,
 7212        bind_interface=None,
 7213        certificate_authority=None,
 7214        client_certificate=None,
 7215        client_key=None,
 7216        database=None,
 7217        egress_filter=None,
 7218        healthy=None,
 7219        hostname=None,
 7220        id=None,
 7221        name=None,
 7222        override_database=None,
 7223        password=None,
 7224        port=None,
 7225        port_override=None,
 7226        secret_store_id=None,
 7227        server_name=None,
 7228        tags=None,
 7229        username=None,
 7230    ):
 7231        self.bind_interface = bind_interface if bind_interface is not None else ''
 7232        '''
 7233         Bind interface
 7234        '''
 7235        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7236        '''
 7237
 7238        '''
 7239        self.client_certificate = client_certificate if client_certificate is not None else ''
 7240        '''
 7241
 7242        '''
 7243        self.client_key = client_key if client_key is not None else ''
 7244        '''
 7245
 7246        '''
 7247        self.database = database if database is not None else ''
 7248        '''
 7249
 7250        '''
 7251        self.egress_filter = egress_filter if egress_filter is not None else ''
 7252        '''
 7253         A filter applied to the routing logic to pin datasource to nodes.
 7254        '''
 7255        self.healthy = healthy if healthy is not None else False
 7256        '''
 7257         True if the datasource is reachable and the credentials are valid.
 7258        '''
 7259        self.hostname = hostname if hostname is not None else ''
 7260        '''
 7261
 7262        '''
 7263        self.id = id if id is not None else ''
 7264        '''
 7265         Unique identifier of the Resource.
 7266        '''
 7267        self.name = name if name is not None else ''
 7268        '''
 7269         Unique human-readable name of the Resource.
 7270        '''
 7271        self.override_database = override_database if override_database is not None else False
 7272        '''
 7273
 7274        '''
 7275        self.password = password if password is not None else ''
 7276        '''
 7277
 7278        '''
 7279        self.port = port if port is not None else 0
 7280        '''
 7281
 7282        '''
 7283        self.port_override = port_override if port_override is not None else 0
 7284        '''
 7285
 7286        '''
 7287        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7288        '''
 7289         ID of the secret store containing credentials for this resource, if any.
 7290        '''
 7291        self.server_name = server_name if server_name is not None else ''
 7292        '''
 7293
 7294        '''
 7295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7296        '''
 7297         Tags is a map of key, value pairs.
 7298        '''
 7299        self.username = username if username is not None else ''
 7300        '''
 7301
 7302        '''
 7303
 7304    def __repr__(self):
 7305        return '<sdm.MTLSPostgres ' + \
 7306            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7307            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7308            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7309            'client_key: ' + repr(self.client_key) + ' ' +\
 7310            'database: ' + repr(self.database) + ' ' +\
 7311            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7312            'healthy: ' + repr(self.healthy) + ' ' +\
 7313            'hostname: ' + repr(self.hostname) + ' ' +\
 7314            'id: ' + repr(self.id) + ' ' +\
 7315            'name: ' + repr(self.name) + ' ' +\
 7316            'override_database: ' + repr(self.override_database) + ' ' +\
 7317            'password: ' + repr(self.password) + ' ' +\
 7318            'port: ' + repr(self.port) + ' ' +\
 7319            'port_override: ' + repr(self.port_override) + ' ' +\
 7320            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7321            'server_name: ' + repr(self.server_name) + ' ' +\
 7322            'tags: ' + repr(self.tags) + ' ' +\
 7323            'username: ' + repr(self.username) + ' ' +\
 7324            '>'
 7325
 7326    def to_dict(self):
 7327        return {
 7328            'bind_interface': self.bind_interface,
 7329            'certificate_authority': self.certificate_authority,
 7330            'client_certificate': self.client_certificate,
 7331            'client_key': self.client_key,
 7332            'database': self.database,
 7333            'egress_filter': self.egress_filter,
 7334            'healthy': self.healthy,
 7335            'hostname': self.hostname,
 7336            'id': self.id,
 7337            'name': self.name,
 7338            'override_database': self.override_database,
 7339            'password': self.password,
 7340            'port': self.port,
 7341            'port_override': self.port_override,
 7342            'secret_store_id': self.secret_store_id,
 7343            'server_name': self.server_name,
 7344            'tags': self.tags,
 7345            'username': self.username,
 7346        }
 7347
 7348    @classmethod
 7349    def from_dict(cls, d):
 7350        return cls(
 7351            bind_interface=d.get('bind_interface'),
 7352            certificate_authority=d.get('certificate_authority'),
 7353            client_certificate=d.get('client_certificate'),
 7354            client_key=d.get('client_key'),
 7355            database=d.get('database'),
 7356            egress_filter=d.get('egress_filter'),
 7357            healthy=d.get('healthy'),
 7358            hostname=d.get('hostname'),
 7359            id=d.get('id'),
 7360            name=d.get('name'),
 7361            override_database=d.get('override_database'),
 7362            password=d.get('password'),
 7363            port=d.get('port'),
 7364            port_override=d.get('port_override'),
 7365            secret_store_id=d.get('secret_store_id'),
 7366            server_name=d.get('server_name'),
 7367            tags=d.get('tags'),
 7368            username=d.get('username'),
 7369        )
 7370
 7371
 7372class Maria:
 7373    '''
 7374
 7375    '''
 7376    __slots__ = [
 7377        'bind_interface',
 7378        'database',
 7379        'egress_filter',
 7380        'healthy',
 7381        'hostname',
 7382        'id',
 7383        'name',
 7384        'password',
 7385        'port',
 7386        'port_override',
 7387        'secret_store_id',
 7388        'tags',
 7389        'username',
 7390    ]
 7391
 7392    def __init__(
 7393        self,
 7394        bind_interface=None,
 7395        database=None,
 7396        egress_filter=None,
 7397        healthy=None,
 7398        hostname=None,
 7399        id=None,
 7400        name=None,
 7401        password=None,
 7402        port=None,
 7403        port_override=None,
 7404        secret_store_id=None,
 7405        tags=None,
 7406        username=None,
 7407    ):
 7408        self.bind_interface = bind_interface if bind_interface is not None else ''
 7409        '''
 7410         Bind interface
 7411        '''
 7412        self.database = database if database is not None else ''
 7413        '''
 7414
 7415        '''
 7416        self.egress_filter = egress_filter if egress_filter is not None else ''
 7417        '''
 7418         A filter applied to the routing logic to pin datasource to nodes.
 7419        '''
 7420        self.healthy = healthy if healthy is not None else False
 7421        '''
 7422         True if the datasource is reachable and the credentials are valid.
 7423        '''
 7424        self.hostname = hostname if hostname is not None else ''
 7425        '''
 7426
 7427        '''
 7428        self.id = id if id is not None else ''
 7429        '''
 7430         Unique identifier of the Resource.
 7431        '''
 7432        self.name = name if name is not None else ''
 7433        '''
 7434         Unique human-readable name of the Resource.
 7435        '''
 7436        self.password = password if password is not None else ''
 7437        '''
 7438
 7439        '''
 7440        self.port = port if port is not None else 0
 7441        '''
 7442
 7443        '''
 7444        self.port_override = port_override if port_override is not None else 0
 7445        '''
 7446
 7447        '''
 7448        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7449        '''
 7450         ID of the secret store containing credentials for this resource, if any.
 7451        '''
 7452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7453        '''
 7454         Tags is a map of key, value pairs.
 7455        '''
 7456        self.username = username if username is not None else ''
 7457        '''
 7458
 7459        '''
 7460
 7461    def __repr__(self):
 7462        return '<sdm.Maria ' + \
 7463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7464            'database: ' + repr(self.database) + ' ' +\
 7465            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7466            'healthy: ' + repr(self.healthy) + ' ' +\
 7467            'hostname: ' + repr(self.hostname) + ' ' +\
 7468            'id: ' + repr(self.id) + ' ' +\
 7469            'name: ' + repr(self.name) + ' ' +\
 7470            'password: ' + repr(self.password) + ' ' +\
 7471            'port: ' + repr(self.port) + ' ' +\
 7472            'port_override: ' + repr(self.port_override) + ' ' +\
 7473            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7474            'tags: ' + repr(self.tags) + ' ' +\
 7475            'username: ' + repr(self.username) + ' ' +\
 7476            '>'
 7477
 7478    def to_dict(self):
 7479        return {
 7480            'bind_interface': self.bind_interface,
 7481            'database': self.database,
 7482            'egress_filter': self.egress_filter,
 7483            'healthy': self.healthy,
 7484            'hostname': self.hostname,
 7485            'id': self.id,
 7486            'name': self.name,
 7487            'password': self.password,
 7488            'port': self.port,
 7489            'port_override': self.port_override,
 7490            'secret_store_id': self.secret_store_id,
 7491            'tags': self.tags,
 7492            'username': self.username,
 7493        }
 7494
 7495    @classmethod
 7496    def from_dict(cls, d):
 7497        return cls(
 7498            bind_interface=d.get('bind_interface'),
 7499            database=d.get('database'),
 7500            egress_filter=d.get('egress_filter'),
 7501            healthy=d.get('healthy'),
 7502            hostname=d.get('hostname'),
 7503            id=d.get('id'),
 7504            name=d.get('name'),
 7505            password=d.get('password'),
 7506            port=d.get('port'),
 7507            port_override=d.get('port_override'),
 7508            secret_store_id=d.get('secret_store_id'),
 7509            tags=d.get('tags'),
 7510            username=d.get('username'),
 7511        )
 7512
 7513
 7514class Memcached:
 7515    '''
 7516
 7517    '''
 7518    __slots__ = [
 7519        'bind_interface',
 7520        'egress_filter',
 7521        'healthy',
 7522        'hostname',
 7523        'id',
 7524        'name',
 7525        'port',
 7526        'port_override',
 7527        'secret_store_id',
 7528        'tags',
 7529    ]
 7530
 7531    def __init__(
 7532        self,
 7533        bind_interface=None,
 7534        egress_filter=None,
 7535        healthy=None,
 7536        hostname=None,
 7537        id=None,
 7538        name=None,
 7539        port=None,
 7540        port_override=None,
 7541        secret_store_id=None,
 7542        tags=None,
 7543    ):
 7544        self.bind_interface = bind_interface if bind_interface is not None else ''
 7545        '''
 7546         Bind interface
 7547        '''
 7548        self.egress_filter = egress_filter if egress_filter is not None else ''
 7549        '''
 7550         A filter applied to the routing logic to pin datasource to nodes.
 7551        '''
 7552        self.healthy = healthy if healthy is not None else False
 7553        '''
 7554         True if the datasource is reachable and the credentials are valid.
 7555        '''
 7556        self.hostname = hostname if hostname is not None else ''
 7557        '''
 7558
 7559        '''
 7560        self.id = id if id is not None else ''
 7561        '''
 7562         Unique identifier of the Resource.
 7563        '''
 7564        self.name = name if name is not None else ''
 7565        '''
 7566         Unique human-readable name of the Resource.
 7567        '''
 7568        self.port = port if port is not None else 0
 7569        '''
 7570
 7571        '''
 7572        self.port_override = port_override if port_override is not None else 0
 7573        '''
 7574
 7575        '''
 7576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7577        '''
 7578         ID of the secret store containing credentials for this resource, if any.
 7579        '''
 7580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7581        '''
 7582         Tags is a map of key, value pairs.
 7583        '''
 7584
 7585    def __repr__(self):
 7586        return '<sdm.Memcached ' + \
 7587            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7588            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7589            'healthy: ' + repr(self.healthy) + ' ' +\
 7590            'hostname: ' + repr(self.hostname) + ' ' +\
 7591            'id: ' + repr(self.id) + ' ' +\
 7592            'name: ' + repr(self.name) + ' ' +\
 7593            'port: ' + repr(self.port) + ' ' +\
 7594            'port_override: ' + repr(self.port_override) + ' ' +\
 7595            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7596            'tags: ' + repr(self.tags) + ' ' +\
 7597            '>'
 7598
 7599    def to_dict(self):
 7600        return {
 7601            'bind_interface': self.bind_interface,
 7602            'egress_filter': self.egress_filter,
 7603            'healthy': self.healthy,
 7604            'hostname': self.hostname,
 7605            'id': self.id,
 7606            'name': self.name,
 7607            'port': self.port,
 7608            'port_override': self.port_override,
 7609            'secret_store_id': self.secret_store_id,
 7610            'tags': self.tags,
 7611        }
 7612
 7613    @classmethod
 7614    def from_dict(cls, d):
 7615        return cls(
 7616            bind_interface=d.get('bind_interface'),
 7617            egress_filter=d.get('egress_filter'),
 7618            healthy=d.get('healthy'),
 7619            hostname=d.get('hostname'),
 7620            id=d.get('id'),
 7621            name=d.get('name'),
 7622            port=d.get('port'),
 7623            port_override=d.get('port_override'),
 7624            secret_store_id=d.get('secret_store_id'),
 7625            tags=d.get('tags'),
 7626        )
 7627
 7628
 7629class Memsql:
 7630    '''
 7631
 7632    '''
 7633    __slots__ = [
 7634        'bind_interface',
 7635        'database',
 7636        'egress_filter',
 7637        'healthy',
 7638        'hostname',
 7639        'id',
 7640        'name',
 7641        'password',
 7642        'port',
 7643        'port_override',
 7644        'secret_store_id',
 7645        'tags',
 7646        'username',
 7647    ]
 7648
 7649    def __init__(
 7650        self,
 7651        bind_interface=None,
 7652        database=None,
 7653        egress_filter=None,
 7654        healthy=None,
 7655        hostname=None,
 7656        id=None,
 7657        name=None,
 7658        password=None,
 7659        port=None,
 7660        port_override=None,
 7661        secret_store_id=None,
 7662        tags=None,
 7663        username=None,
 7664    ):
 7665        self.bind_interface = bind_interface if bind_interface is not None else ''
 7666        '''
 7667         Bind interface
 7668        '''
 7669        self.database = database if database is not None else ''
 7670        '''
 7671
 7672        '''
 7673        self.egress_filter = egress_filter if egress_filter is not None else ''
 7674        '''
 7675         A filter applied to the routing logic to pin datasource to nodes.
 7676        '''
 7677        self.healthy = healthy if healthy is not None else False
 7678        '''
 7679         True if the datasource is reachable and the credentials are valid.
 7680        '''
 7681        self.hostname = hostname if hostname is not None else ''
 7682        '''
 7683
 7684        '''
 7685        self.id = id if id is not None else ''
 7686        '''
 7687         Unique identifier of the Resource.
 7688        '''
 7689        self.name = name if name is not None else ''
 7690        '''
 7691         Unique human-readable name of the Resource.
 7692        '''
 7693        self.password = password if password is not None else ''
 7694        '''
 7695
 7696        '''
 7697        self.port = port if port is not None else 0
 7698        '''
 7699
 7700        '''
 7701        self.port_override = port_override if port_override is not None else 0
 7702        '''
 7703
 7704        '''
 7705        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7706        '''
 7707         ID of the secret store containing credentials for this resource, if any.
 7708        '''
 7709        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7710        '''
 7711         Tags is a map of key, value pairs.
 7712        '''
 7713        self.username = username if username is not None else ''
 7714        '''
 7715
 7716        '''
 7717
 7718    def __repr__(self):
 7719        return '<sdm.Memsql ' + \
 7720            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7721            'database: ' + repr(self.database) + ' ' +\
 7722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7723            'healthy: ' + repr(self.healthy) + ' ' +\
 7724            'hostname: ' + repr(self.hostname) + ' ' +\
 7725            'id: ' + repr(self.id) + ' ' +\
 7726            'name: ' + repr(self.name) + ' ' +\
 7727            'password: ' + repr(self.password) + ' ' +\
 7728            'port: ' + repr(self.port) + ' ' +\
 7729            'port_override: ' + repr(self.port_override) + ' ' +\
 7730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7731            'tags: ' + repr(self.tags) + ' ' +\
 7732            'username: ' + repr(self.username) + ' ' +\
 7733            '>'
 7734
 7735    def to_dict(self):
 7736        return {
 7737            'bind_interface': self.bind_interface,
 7738            'database': self.database,
 7739            'egress_filter': self.egress_filter,
 7740            'healthy': self.healthy,
 7741            'hostname': self.hostname,
 7742            'id': self.id,
 7743            'name': self.name,
 7744            'password': self.password,
 7745            'port': self.port,
 7746            'port_override': self.port_override,
 7747            'secret_store_id': self.secret_store_id,
 7748            'tags': self.tags,
 7749            'username': self.username,
 7750        }
 7751
 7752    @classmethod
 7753    def from_dict(cls, d):
 7754        return cls(
 7755            bind_interface=d.get('bind_interface'),
 7756            database=d.get('database'),
 7757            egress_filter=d.get('egress_filter'),
 7758            healthy=d.get('healthy'),
 7759            hostname=d.get('hostname'),
 7760            id=d.get('id'),
 7761            name=d.get('name'),
 7762            password=d.get('password'),
 7763            port=d.get('port'),
 7764            port_override=d.get('port_override'),
 7765            secret_store_id=d.get('secret_store_id'),
 7766            tags=d.get('tags'),
 7767            username=d.get('username'),
 7768        )
 7769
 7770
 7771class MongoHost:
 7772    '''
 7773
 7774    '''
 7775    __slots__ = [
 7776        'auth_database',
 7777        'bind_interface',
 7778        'egress_filter',
 7779        'healthy',
 7780        'hostname',
 7781        'id',
 7782        'name',
 7783        'password',
 7784        'port',
 7785        'port_override',
 7786        'secret_store_id',
 7787        'tags',
 7788        'tls_required',
 7789        'username',
 7790    ]
 7791
 7792    def __init__(
 7793        self,
 7794        auth_database=None,
 7795        bind_interface=None,
 7796        egress_filter=None,
 7797        healthy=None,
 7798        hostname=None,
 7799        id=None,
 7800        name=None,
 7801        password=None,
 7802        port=None,
 7803        port_override=None,
 7804        secret_store_id=None,
 7805        tags=None,
 7806        tls_required=None,
 7807        username=None,
 7808    ):
 7809        self.auth_database = auth_database if auth_database is not None else ''
 7810        '''
 7811
 7812        '''
 7813        self.bind_interface = bind_interface if bind_interface is not None else ''
 7814        '''
 7815         Bind interface
 7816        '''
 7817        self.egress_filter = egress_filter if egress_filter is not None else ''
 7818        '''
 7819         A filter applied to the routing logic to pin datasource to nodes.
 7820        '''
 7821        self.healthy = healthy if healthy is not None else False
 7822        '''
 7823         True if the datasource is reachable and the credentials are valid.
 7824        '''
 7825        self.hostname = hostname if hostname is not None else ''
 7826        '''
 7827
 7828        '''
 7829        self.id = id if id is not None else ''
 7830        '''
 7831         Unique identifier of the Resource.
 7832        '''
 7833        self.name = name if name is not None else ''
 7834        '''
 7835         Unique human-readable name of the Resource.
 7836        '''
 7837        self.password = password if password is not None else ''
 7838        '''
 7839
 7840        '''
 7841        self.port = port if port is not None else 0
 7842        '''
 7843
 7844        '''
 7845        self.port_override = port_override if port_override is not None else 0
 7846        '''
 7847
 7848        '''
 7849        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7850        '''
 7851         ID of the secret store containing credentials for this resource, if any.
 7852        '''
 7853        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7854        '''
 7855         Tags is a map of key, value pairs.
 7856        '''
 7857        self.tls_required = tls_required if tls_required is not None else False
 7858        '''
 7859
 7860        '''
 7861        self.username = username if username is not None else ''
 7862        '''
 7863
 7864        '''
 7865
 7866    def __repr__(self):
 7867        return '<sdm.MongoHost ' + \
 7868            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7871            'healthy: ' + repr(self.healthy) + ' ' +\
 7872            'hostname: ' + repr(self.hostname) + ' ' +\
 7873            'id: ' + repr(self.id) + ' ' +\
 7874            'name: ' + repr(self.name) + ' ' +\
 7875            'password: ' + repr(self.password) + ' ' +\
 7876            'port: ' + repr(self.port) + ' ' +\
 7877            'port_override: ' + repr(self.port_override) + ' ' +\
 7878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7879            'tags: ' + repr(self.tags) + ' ' +\
 7880            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7881            'username: ' + repr(self.username) + ' ' +\
 7882            '>'
 7883
 7884    def to_dict(self):
 7885        return {
 7886            'auth_database': self.auth_database,
 7887            'bind_interface': self.bind_interface,
 7888            'egress_filter': self.egress_filter,
 7889            'healthy': self.healthy,
 7890            'hostname': self.hostname,
 7891            'id': self.id,
 7892            'name': self.name,
 7893            'password': self.password,
 7894            'port': self.port,
 7895            'port_override': self.port_override,
 7896            'secret_store_id': self.secret_store_id,
 7897            'tags': self.tags,
 7898            'tls_required': self.tls_required,
 7899            'username': self.username,
 7900        }
 7901
 7902    @classmethod
 7903    def from_dict(cls, d):
 7904        return cls(
 7905            auth_database=d.get('auth_database'),
 7906            bind_interface=d.get('bind_interface'),
 7907            egress_filter=d.get('egress_filter'),
 7908            healthy=d.get('healthy'),
 7909            hostname=d.get('hostname'),
 7910            id=d.get('id'),
 7911            name=d.get('name'),
 7912            password=d.get('password'),
 7913            port=d.get('port'),
 7914            port_override=d.get('port_override'),
 7915            secret_store_id=d.get('secret_store_id'),
 7916            tags=d.get('tags'),
 7917            tls_required=d.get('tls_required'),
 7918            username=d.get('username'),
 7919        )
 7920
 7921
 7922class MongoLegacyHost:
 7923    '''
 7924
 7925    '''
 7926    __slots__ = [
 7927        'auth_database',
 7928        'bind_interface',
 7929        'egress_filter',
 7930        'healthy',
 7931        'hostname',
 7932        'id',
 7933        'name',
 7934        'password',
 7935        'port',
 7936        'port_override',
 7937        'replica_set',
 7938        'secret_store_id',
 7939        'tags',
 7940        'tls_required',
 7941        'username',
 7942    ]
 7943
 7944    def __init__(
 7945        self,
 7946        auth_database=None,
 7947        bind_interface=None,
 7948        egress_filter=None,
 7949        healthy=None,
 7950        hostname=None,
 7951        id=None,
 7952        name=None,
 7953        password=None,
 7954        port=None,
 7955        port_override=None,
 7956        replica_set=None,
 7957        secret_store_id=None,
 7958        tags=None,
 7959        tls_required=None,
 7960        username=None,
 7961    ):
 7962        self.auth_database = auth_database if auth_database is not None else ''
 7963        '''
 7964
 7965        '''
 7966        self.bind_interface = bind_interface if bind_interface is not None else ''
 7967        '''
 7968         Bind interface
 7969        '''
 7970        self.egress_filter = egress_filter if egress_filter is not None else ''
 7971        '''
 7972         A filter applied to the routing logic to pin datasource to nodes.
 7973        '''
 7974        self.healthy = healthy if healthy is not None else False
 7975        '''
 7976         True if the datasource is reachable and the credentials are valid.
 7977        '''
 7978        self.hostname = hostname if hostname is not None else ''
 7979        '''
 7980
 7981        '''
 7982        self.id = id if id is not None else ''
 7983        '''
 7984         Unique identifier of the Resource.
 7985        '''
 7986        self.name = name if name is not None else ''
 7987        '''
 7988         Unique human-readable name of the Resource.
 7989        '''
 7990        self.password = password if password is not None else ''
 7991        '''
 7992
 7993        '''
 7994        self.port = port if port is not None else 0
 7995        '''
 7996
 7997        '''
 7998        self.port_override = port_override if port_override is not None else 0
 7999        '''
 8000
 8001        '''
 8002        self.replica_set = replica_set if replica_set is not None else ''
 8003        '''
 8004
 8005        '''
 8006        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8007        '''
 8008         ID of the secret store containing credentials for this resource, if any.
 8009        '''
 8010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8011        '''
 8012         Tags is a map of key, value pairs.
 8013        '''
 8014        self.tls_required = tls_required if tls_required is not None else False
 8015        '''
 8016
 8017        '''
 8018        self.username = username if username is not None else ''
 8019        '''
 8020
 8021        '''
 8022
 8023    def __repr__(self):
 8024        return '<sdm.MongoLegacyHost ' + \
 8025            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8026            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8027            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8028            'healthy: ' + repr(self.healthy) + ' ' +\
 8029            'hostname: ' + repr(self.hostname) + ' ' +\
 8030            'id: ' + repr(self.id) + ' ' +\
 8031            'name: ' + repr(self.name) + ' ' +\
 8032            'password: ' + repr(self.password) + ' ' +\
 8033            'port: ' + repr(self.port) + ' ' +\
 8034            'port_override: ' + repr(self.port_override) + ' ' +\
 8035            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8036            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8037            'tags: ' + repr(self.tags) + ' ' +\
 8038            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8039            'username: ' + repr(self.username) + ' ' +\
 8040            '>'
 8041
 8042    def to_dict(self):
 8043        return {
 8044            'auth_database': self.auth_database,
 8045            'bind_interface': self.bind_interface,
 8046            'egress_filter': self.egress_filter,
 8047            'healthy': self.healthy,
 8048            'hostname': self.hostname,
 8049            'id': self.id,
 8050            'name': self.name,
 8051            'password': self.password,
 8052            'port': self.port,
 8053            'port_override': self.port_override,
 8054            'replica_set': self.replica_set,
 8055            'secret_store_id': self.secret_store_id,
 8056            'tags': self.tags,
 8057            'tls_required': self.tls_required,
 8058            'username': self.username,
 8059        }
 8060
 8061    @classmethod
 8062    def from_dict(cls, d):
 8063        return cls(
 8064            auth_database=d.get('auth_database'),
 8065            bind_interface=d.get('bind_interface'),
 8066            egress_filter=d.get('egress_filter'),
 8067            healthy=d.get('healthy'),
 8068            hostname=d.get('hostname'),
 8069            id=d.get('id'),
 8070            name=d.get('name'),
 8071            password=d.get('password'),
 8072            port=d.get('port'),
 8073            port_override=d.get('port_override'),
 8074            replica_set=d.get('replica_set'),
 8075            secret_store_id=d.get('secret_store_id'),
 8076            tags=d.get('tags'),
 8077            tls_required=d.get('tls_required'),
 8078            username=d.get('username'),
 8079        )
 8080
 8081
 8082class MongoLegacyReplicaset:
 8083    '''
 8084
 8085    '''
 8086    __slots__ = [
 8087        'auth_database',
 8088        'bind_interface',
 8089        'connect_to_replica',
 8090        'egress_filter',
 8091        'healthy',
 8092        'hostname',
 8093        'id',
 8094        'name',
 8095        'password',
 8096        'port',
 8097        'port_override',
 8098        'replica_set',
 8099        'secret_store_id',
 8100        'tags',
 8101        'tls_required',
 8102        'username',
 8103    ]
 8104
 8105    def __init__(
 8106        self,
 8107        auth_database=None,
 8108        bind_interface=None,
 8109        connect_to_replica=None,
 8110        egress_filter=None,
 8111        healthy=None,
 8112        hostname=None,
 8113        id=None,
 8114        name=None,
 8115        password=None,
 8116        port=None,
 8117        port_override=None,
 8118        replica_set=None,
 8119        secret_store_id=None,
 8120        tags=None,
 8121        tls_required=None,
 8122        username=None,
 8123    ):
 8124        self.auth_database = auth_database if auth_database is not None else ''
 8125        '''
 8126
 8127        '''
 8128        self.bind_interface = bind_interface if bind_interface is not None else ''
 8129        '''
 8130         Bind interface
 8131        '''
 8132        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8133        '''
 8134
 8135        '''
 8136        self.egress_filter = egress_filter if egress_filter is not None else ''
 8137        '''
 8138         A filter applied to the routing logic to pin datasource to nodes.
 8139        '''
 8140        self.healthy = healthy if healthy is not None else False
 8141        '''
 8142         True if the datasource is reachable and the credentials are valid.
 8143        '''
 8144        self.hostname = hostname if hostname is not None else ''
 8145        '''
 8146
 8147        '''
 8148        self.id = id if id is not None else ''
 8149        '''
 8150         Unique identifier of the Resource.
 8151        '''
 8152        self.name = name if name is not None else ''
 8153        '''
 8154         Unique human-readable name of the Resource.
 8155        '''
 8156        self.password = password if password is not None else ''
 8157        '''
 8158
 8159        '''
 8160        self.port = port if port is not None else 0
 8161        '''
 8162
 8163        '''
 8164        self.port_override = port_override if port_override is not None else 0
 8165        '''
 8166
 8167        '''
 8168        self.replica_set = replica_set if replica_set is not None else ''
 8169        '''
 8170
 8171        '''
 8172        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8173        '''
 8174         ID of the secret store containing credentials for this resource, if any.
 8175        '''
 8176        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8177        '''
 8178         Tags is a map of key, value pairs.
 8179        '''
 8180        self.tls_required = tls_required if tls_required is not None else False
 8181        '''
 8182
 8183        '''
 8184        self.username = username if username is not None else ''
 8185        '''
 8186
 8187        '''
 8188
 8189    def __repr__(self):
 8190        return '<sdm.MongoLegacyReplicaset ' + \
 8191            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8192            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8193            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8194            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8195            'healthy: ' + repr(self.healthy) + ' ' +\
 8196            'hostname: ' + repr(self.hostname) + ' ' +\
 8197            'id: ' + repr(self.id) + ' ' +\
 8198            'name: ' + repr(self.name) + ' ' +\
 8199            'password: ' + repr(self.password) + ' ' +\
 8200            'port: ' + repr(self.port) + ' ' +\
 8201            'port_override: ' + repr(self.port_override) + ' ' +\
 8202            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8204            'tags: ' + repr(self.tags) + ' ' +\
 8205            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8206            'username: ' + repr(self.username) + ' ' +\
 8207            '>'
 8208
 8209    def to_dict(self):
 8210        return {
 8211            'auth_database': self.auth_database,
 8212            'bind_interface': self.bind_interface,
 8213            'connect_to_replica': self.connect_to_replica,
 8214            'egress_filter': self.egress_filter,
 8215            'healthy': self.healthy,
 8216            'hostname': self.hostname,
 8217            'id': self.id,
 8218            'name': self.name,
 8219            'password': self.password,
 8220            'port': self.port,
 8221            'port_override': self.port_override,
 8222            'replica_set': self.replica_set,
 8223            'secret_store_id': self.secret_store_id,
 8224            'tags': self.tags,
 8225            'tls_required': self.tls_required,
 8226            'username': self.username,
 8227        }
 8228
 8229    @classmethod
 8230    def from_dict(cls, d):
 8231        return cls(
 8232            auth_database=d.get('auth_database'),
 8233            bind_interface=d.get('bind_interface'),
 8234            connect_to_replica=d.get('connect_to_replica'),
 8235            egress_filter=d.get('egress_filter'),
 8236            healthy=d.get('healthy'),
 8237            hostname=d.get('hostname'),
 8238            id=d.get('id'),
 8239            name=d.get('name'),
 8240            password=d.get('password'),
 8241            port=d.get('port'),
 8242            port_override=d.get('port_override'),
 8243            replica_set=d.get('replica_set'),
 8244            secret_store_id=d.get('secret_store_id'),
 8245            tags=d.get('tags'),
 8246            tls_required=d.get('tls_required'),
 8247            username=d.get('username'),
 8248        )
 8249
 8250
 8251class MongoReplicaSet:
 8252    '''
 8253
 8254    '''
 8255    __slots__ = [
 8256        'auth_database',
 8257        'bind_interface',
 8258        'connect_to_replica',
 8259        'egress_filter',
 8260        'healthy',
 8261        'hostname',
 8262        'id',
 8263        'name',
 8264        'password',
 8265        'port',
 8266        'port_override',
 8267        'replica_set',
 8268        'secret_store_id',
 8269        'tags',
 8270        'tls_required',
 8271        'username',
 8272    ]
 8273
 8274    def __init__(
 8275        self,
 8276        auth_database=None,
 8277        bind_interface=None,
 8278        connect_to_replica=None,
 8279        egress_filter=None,
 8280        healthy=None,
 8281        hostname=None,
 8282        id=None,
 8283        name=None,
 8284        password=None,
 8285        port=None,
 8286        port_override=None,
 8287        replica_set=None,
 8288        secret_store_id=None,
 8289        tags=None,
 8290        tls_required=None,
 8291        username=None,
 8292    ):
 8293        self.auth_database = auth_database if auth_database is not None else ''
 8294        '''
 8295
 8296        '''
 8297        self.bind_interface = bind_interface if bind_interface is not None else ''
 8298        '''
 8299         Bind interface
 8300        '''
 8301        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8302        '''
 8303
 8304        '''
 8305        self.egress_filter = egress_filter if egress_filter is not None else ''
 8306        '''
 8307         A filter applied to the routing logic to pin datasource to nodes.
 8308        '''
 8309        self.healthy = healthy if healthy is not None else False
 8310        '''
 8311         True if the datasource is reachable and the credentials are valid.
 8312        '''
 8313        self.hostname = hostname if hostname is not None else ''
 8314        '''
 8315
 8316        '''
 8317        self.id = id if id is not None else ''
 8318        '''
 8319         Unique identifier of the Resource.
 8320        '''
 8321        self.name = name if name is not None else ''
 8322        '''
 8323         Unique human-readable name of the Resource.
 8324        '''
 8325        self.password = password if password is not None else ''
 8326        '''
 8327
 8328        '''
 8329        self.port = port if port is not None else 0
 8330        '''
 8331
 8332        '''
 8333        self.port_override = port_override if port_override is not None else 0
 8334        '''
 8335
 8336        '''
 8337        self.replica_set = replica_set if replica_set is not None else ''
 8338        '''
 8339
 8340        '''
 8341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8342        '''
 8343         ID of the secret store containing credentials for this resource, if any.
 8344        '''
 8345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8346        '''
 8347         Tags is a map of key, value pairs.
 8348        '''
 8349        self.tls_required = tls_required if tls_required is not None else False
 8350        '''
 8351
 8352        '''
 8353        self.username = username if username is not None else ''
 8354        '''
 8355
 8356        '''
 8357
 8358    def __repr__(self):
 8359        return '<sdm.MongoReplicaSet ' + \
 8360            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8361            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8362            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8363            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8364            'healthy: ' + repr(self.healthy) + ' ' +\
 8365            'hostname: ' + repr(self.hostname) + ' ' +\
 8366            'id: ' + repr(self.id) + ' ' +\
 8367            'name: ' + repr(self.name) + ' ' +\
 8368            'password: ' + repr(self.password) + ' ' +\
 8369            'port: ' + repr(self.port) + ' ' +\
 8370            'port_override: ' + repr(self.port_override) + ' ' +\
 8371            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8372            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8373            'tags: ' + repr(self.tags) + ' ' +\
 8374            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8375            'username: ' + repr(self.username) + ' ' +\
 8376            '>'
 8377
 8378    def to_dict(self):
 8379        return {
 8380            'auth_database': self.auth_database,
 8381            'bind_interface': self.bind_interface,
 8382            'connect_to_replica': self.connect_to_replica,
 8383            'egress_filter': self.egress_filter,
 8384            'healthy': self.healthy,
 8385            'hostname': self.hostname,
 8386            'id': self.id,
 8387            'name': self.name,
 8388            'password': self.password,
 8389            'port': self.port,
 8390            'port_override': self.port_override,
 8391            'replica_set': self.replica_set,
 8392            'secret_store_id': self.secret_store_id,
 8393            'tags': self.tags,
 8394            'tls_required': self.tls_required,
 8395            'username': self.username,
 8396        }
 8397
 8398    @classmethod
 8399    def from_dict(cls, d):
 8400        return cls(
 8401            auth_database=d.get('auth_database'),
 8402            bind_interface=d.get('bind_interface'),
 8403            connect_to_replica=d.get('connect_to_replica'),
 8404            egress_filter=d.get('egress_filter'),
 8405            healthy=d.get('healthy'),
 8406            hostname=d.get('hostname'),
 8407            id=d.get('id'),
 8408            name=d.get('name'),
 8409            password=d.get('password'),
 8410            port=d.get('port'),
 8411            port_override=d.get('port_override'),
 8412            replica_set=d.get('replica_set'),
 8413            secret_store_id=d.get('secret_store_id'),
 8414            tags=d.get('tags'),
 8415            tls_required=d.get('tls_required'),
 8416            username=d.get('username'),
 8417        )
 8418
 8419
 8420class MongoShardedCluster:
 8421    '''
 8422
 8423    '''
 8424    __slots__ = [
 8425        'auth_database',
 8426        'bind_interface',
 8427        'egress_filter',
 8428        'healthy',
 8429        'hostname',
 8430        'id',
 8431        'name',
 8432        'password',
 8433        'port_override',
 8434        'secret_store_id',
 8435        'tags',
 8436        'tls_required',
 8437        'username',
 8438    ]
 8439
 8440    def __init__(
 8441        self,
 8442        auth_database=None,
 8443        bind_interface=None,
 8444        egress_filter=None,
 8445        healthy=None,
 8446        hostname=None,
 8447        id=None,
 8448        name=None,
 8449        password=None,
 8450        port_override=None,
 8451        secret_store_id=None,
 8452        tags=None,
 8453        tls_required=None,
 8454        username=None,
 8455    ):
 8456        self.auth_database = auth_database if auth_database is not None else ''
 8457        '''
 8458
 8459        '''
 8460        self.bind_interface = bind_interface if bind_interface is not None else ''
 8461        '''
 8462         Bind interface
 8463        '''
 8464        self.egress_filter = egress_filter if egress_filter is not None else ''
 8465        '''
 8466         A filter applied to the routing logic to pin datasource to nodes.
 8467        '''
 8468        self.healthy = healthy if healthy is not None else False
 8469        '''
 8470         True if the datasource is reachable and the credentials are valid.
 8471        '''
 8472        self.hostname = hostname if hostname is not None else ''
 8473        '''
 8474
 8475        '''
 8476        self.id = id if id is not None else ''
 8477        '''
 8478         Unique identifier of the Resource.
 8479        '''
 8480        self.name = name if name is not None else ''
 8481        '''
 8482         Unique human-readable name of the Resource.
 8483        '''
 8484        self.password = password if password is not None else ''
 8485        '''
 8486
 8487        '''
 8488        self.port_override = port_override if port_override is not None else 0
 8489        '''
 8490
 8491        '''
 8492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8493        '''
 8494         ID of the secret store containing credentials for this resource, if any.
 8495        '''
 8496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8497        '''
 8498         Tags is a map of key, value pairs.
 8499        '''
 8500        self.tls_required = tls_required if tls_required is not None else False
 8501        '''
 8502
 8503        '''
 8504        self.username = username if username is not None else ''
 8505        '''
 8506
 8507        '''
 8508
 8509    def __repr__(self):
 8510        return '<sdm.MongoShardedCluster ' + \
 8511            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8512            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8513            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8514            'healthy: ' + repr(self.healthy) + ' ' +\
 8515            'hostname: ' + repr(self.hostname) + ' ' +\
 8516            'id: ' + repr(self.id) + ' ' +\
 8517            'name: ' + repr(self.name) + ' ' +\
 8518            'password: ' + repr(self.password) + ' ' +\
 8519            'port_override: ' + repr(self.port_override) + ' ' +\
 8520            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8521            'tags: ' + repr(self.tags) + ' ' +\
 8522            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8523            'username: ' + repr(self.username) + ' ' +\
 8524            '>'
 8525
 8526    def to_dict(self):
 8527        return {
 8528            'auth_database': self.auth_database,
 8529            'bind_interface': self.bind_interface,
 8530            'egress_filter': self.egress_filter,
 8531            'healthy': self.healthy,
 8532            'hostname': self.hostname,
 8533            'id': self.id,
 8534            'name': self.name,
 8535            'password': self.password,
 8536            'port_override': self.port_override,
 8537            'secret_store_id': self.secret_store_id,
 8538            'tags': self.tags,
 8539            'tls_required': self.tls_required,
 8540            'username': self.username,
 8541        }
 8542
 8543    @classmethod
 8544    def from_dict(cls, d):
 8545        return cls(
 8546            auth_database=d.get('auth_database'),
 8547            bind_interface=d.get('bind_interface'),
 8548            egress_filter=d.get('egress_filter'),
 8549            healthy=d.get('healthy'),
 8550            hostname=d.get('hostname'),
 8551            id=d.get('id'),
 8552            name=d.get('name'),
 8553            password=d.get('password'),
 8554            port_override=d.get('port_override'),
 8555            secret_store_id=d.get('secret_store_id'),
 8556            tags=d.get('tags'),
 8557            tls_required=d.get('tls_required'),
 8558            username=d.get('username'),
 8559        )
 8560
 8561
 8562class Mysql:
 8563    '''
 8564
 8565    '''
 8566    __slots__ = [
 8567        'bind_interface',
 8568        'database',
 8569        'egress_filter',
 8570        'healthy',
 8571        'hostname',
 8572        'id',
 8573        'name',
 8574        'password',
 8575        'port',
 8576        'port_override',
 8577        'secret_store_id',
 8578        'tags',
 8579        'username',
 8580    ]
 8581
 8582    def __init__(
 8583        self,
 8584        bind_interface=None,
 8585        database=None,
 8586        egress_filter=None,
 8587        healthy=None,
 8588        hostname=None,
 8589        id=None,
 8590        name=None,
 8591        password=None,
 8592        port=None,
 8593        port_override=None,
 8594        secret_store_id=None,
 8595        tags=None,
 8596        username=None,
 8597    ):
 8598        self.bind_interface = bind_interface if bind_interface is not None else ''
 8599        '''
 8600         Bind interface
 8601        '''
 8602        self.database = database if database is not None else ''
 8603        '''
 8604
 8605        '''
 8606        self.egress_filter = egress_filter if egress_filter is not None else ''
 8607        '''
 8608         A filter applied to the routing logic to pin datasource to nodes.
 8609        '''
 8610        self.healthy = healthy if healthy is not None else False
 8611        '''
 8612         True if the datasource is reachable and the credentials are valid.
 8613        '''
 8614        self.hostname = hostname if hostname is not None else ''
 8615        '''
 8616
 8617        '''
 8618        self.id = id if id is not None else ''
 8619        '''
 8620         Unique identifier of the Resource.
 8621        '''
 8622        self.name = name if name is not None else ''
 8623        '''
 8624         Unique human-readable name of the Resource.
 8625        '''
 8626        self.password = password if password is not None else ''
 8627        '''
 8628
 8629        '''
 8630        self.port = port if port is not None else 0
 8631        '''
 8632
 8633        '''
 8634        self.port_override = port_override if port_override is not None else 0
 8635        '''
 8636
 8637        '''
 8638        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8639        '''
 8640         ID of the secret store containing credentials for this resource, if any.
 8641        '''
 8642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8643        '''
 8644         Tags is a map of key, value pairs.
 8645        '''
 8646        self.username = username if username is not None else ''
 8647        '''
 8648
 8649        '''
 8650
 8651    def __repr__(self):
 8652        return '<sdm.Mysql ' + \
 8653            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8654            'database: ' + repr(self.database) + ' ' +\
 8655            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8656            'healthy: ' + repr(self.healthy) + ' ' +\
 8657            'hostname: ' + repr(self.hostname) + ' ' +\
 8658            'id: ' + repr(self.id) + ' ' +\
 8659            'name: ' + repr(self.name) + ' ' +\
 8660            'password: ' + repr(self.password) + ' ' +\
 8661            'port: ' + repr(self.port) + ' ' +\
 8662            'port_override: ' + repr(self.port_override) + ' ' +\
 8663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8664            'tags: ' + repr(self.tags) + ' ' +\
 8665            'username: ' + repr(self.username) + ' ' +\
 8666            '>'
 8667
 8668    def to_dict(self):
 8669        return {
 8670            'bind_interface': self.bind_interface,
 8671            'database': self.database,
 8672            'egress_filter': self.egress_filter,
 8673            'healthy': self.healthy,
 8674            'hostname': self.hostname,
 8675            'id': self.id,
 8676            'name': self.name,
 8677            'password': self.password,
 8678            'port': self.port,
 8679            'port_override': self.port_override,
 8680            'secret_store_id': self.secret_store_id,
 8681            'tags': self.tags,
 8682            'username': self.username,
 8683        }
 8684
 8685    @classmethod
 8686    def from_dict(cls, d):
 8687        return cls(
 8688            bind_interface=d.get('bind_interface'),
 8689            database=d.get('database'),
 8690            egress_filter=d.get('egress_filter'),
 8691            healthy=d.get('healthy'),
 8692            hostname=d.get('hostname'),
 8693            id=d.get('id'),
 8694            name=d.get('name'),
 8695            password=d.get('password'),
 8696            port=d.get('port'),
 8697            port_override=d.get('port_override'),
 8698            secret_store_id=d.get('secret_store_id'),
 8699            tags=d.get('tags'),
 8700            username=d.get('username'),
 8701        )
 8702
 8703
 8704class Neptune:
 8705    '''
 8706
 8707    '''
 8708    __slots__ = [
 8709        'bind_interface',
 8710        'egress_filter',
 8711        'endpoint',
 8712        'healthy',
 8713        'id',
 8714        'name',
 8715        'port',
 8716        'port_override',
 8717        'secret_store_id',
 8718        'tags',
 8719    ]
 8720
 8721    def __init__(
 8722        self,
 8723        bind_interface=None,
 8724        egress_filter=None,
 8725        endpoint=None,
 8726        healthy=None,
 8727        id=None,
 8728        name=None,
 8729        port=None,
 8730        port_override=None,
 8731        secret_store_id=None,
 8732        tags=None,
 8733    ):
 8734        self.bind_interface = bind_interface if bind_interface is not None else ''
 8735        '''
 8736         Bind interface
 8737        '''
 8738        self.egress_filter = egress_filter if egress_filter is not None else ''
 8739        '''
 8740         A filter applied to the routing logic to pin datasource to nodes.
 8741        '''
 8742        self.endpoint = endpoint if endpoint is not None else ''
 8743        '''
 8744
 8745        '''
 8746        self.healthy = healthy if healthy is not None else False
 8747        '''
 8748         True if the datasource is reachable and the credentials are valid.
 8749        '''
 8750        self.id = id if id is not None else ''
 8751        '''
 8752         Unique identifier of the Resource.
 8753        '''
 8754        self.name = name if name is not None else ''
 8755        '''
 8756         Unique human-readable name of the Resource.
 8757        '''
 8758        self.port = port if port is not None else 0
 8759        '''
 8760
 8761        '''
 8762        self.port_override = port_override if port_override is not None else 0
 8763        '''
 8764
 8765        '''
 8766        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8767        '''
 8768         ID of the secret store containing credentials for this resource, if any.
 8769        '''
 8770        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8771        '''
 8772         Tags is a map of key, value pairs.
 8773        '''
 8774
 8775    def __repr__(self):
 8776        return '<sdm.Neptune ' + \
 8777            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8778            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8779            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8780            'healthy: ' + repr(self.healthy) + ' ' +\
 8781            'id: ' + repr(self.id) + ' ' +\
 8782            'name: ' + repr(self.name) + ' ' +\
 8783            'port: ' + repr(self.port) + ' ' +\
 8784            'port_override: ' + repr(self.port_override) + ' ' +\
 8785            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8786            'tags: ' + repr(self.tags) + ' ' +\
 8787            '>'
 8788
 8789    def to_dict(self):
 8790        return {
 8791            'bind_interface': self.bind_interface,
 8792            'egress_filter': self.egress_filter,
 8793            'endpoint': self.endpoint,
 8794            'healthy': self.healthy,
 8795            'id': self.id,
 8796            'name': self.name,
 8797            'port': self.port,
 8798            'port_override': self.port_override,
 8799            'secret_store_id': self.secret_store_id,
 8800            'tags': self.tags,
 8801        }
 8802
 8803    @classmethod
 8804    def from_dict(cls, d):
 8805        return cls(
 8806            bind_interface=d.get('bind_interface'),
 8807            egress_filter=d.get('egress_filter'),
 8808            endpoint=d.get('endpoint'),
 8809            healthy=d.get('healthy'),
 8810            id=d.get('id'),
 8811            name=d.get('name'),
 8812            port=d.get('port'),
 8813            port_override=d.get('port_override'),
 8814            secret_store_id=d.get('secret_store_id'),
 8815            tags=d.get('tags'),
 8816        )
 8817
 8818
 8819class NeptuneIAM:
 8820    '''
 8821
 8822    '''
 8823    __slots__ = [
 8824        'access_key',
 8825        'bind_interface',
 8826        'egress_filter',
 8827        'endpoint',
 8828        'healthy',
 8829        'id',
 8830        'name',
 8831        'port',
 8832        'port_override',
 8833        'region',
 8834        'role_arn',
 8835        'role_external_id',
 8836        'secret_access_key',
 8837        'secret_store_id',
 8838        'tags',
 8839    ]
 8840
 8841    def __init__(
 8842        self,
 8843        access_key=None,
 8844        bind_interface=None,
 8845        egress_filter=None,
 8846        endpoint=None,
 8847        healthy=None,
 8848        id=None,
 8849        name=None,
 8850        port=None,
 8851        port_override=None,
 8852        region=None,
 8853        role_arn=None,
 8854        role_external_id=None,
 8855        secret_access_key=None,
 8856        secret_store_id=None,
 8857        tags=None,
 8858    ):
 8859        self.access_key = access_key if access_key is not None else ''
 8860        '''
 8861
 8862        '''
 8863        self.bind_interface = bind_interface if bind_interface is not None else ''
 8864        '''
 8865         Bind interface
 8866        '''
 8867        self.egress_filter = egress_filter if egress_filter is not None else ''
 8868        '''
 8869         A filter applied to the routing logic to pin datasource to nodes.
 8870        '''
 8871        self.endpoint = endpoint if endpoint is not None else ''
 8872        '''
 8873
 8874        '''
 8875        self.healthy = healthy if healthy is not None else False
 8876        '''
 8877         True if the datasource is reachable and the credentials are valid.
 8878        '''
 8879        self.id = id if id is not None else ''
 8880        '''
 8881         Unique identifier of the Resource.
 8882        '''
 8883        self.name = name if name is not None else ''
 8884        '''
 8885         Unique human-readable name of the Resource.
 8886        '''
 8887        self.port = port if port is not None else 0
 8888        '''
 8889
 8890        '''
 8891        self.port_override = port_override if port_override is not None else 0
 8892        '''
 8893
 8894        '''
 8895        self.region = region if region is not None else ''
 8896        '''
 8897
 8898        '''
 8899        self.role_arn = role_arn if role_arn is not None else ''
 8900        '''
 8901
 8902        '''
 8903        self.role_external_id = role_external_id if role_external_id is not None else ''
 8904        '''
 8905
 8906        '''
 8907        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8908        '''
 8909
 8910        '''
 8911        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8912        '''
 8913         ID of the secret store containing credentials for this resource, if any.
 8914        '''
 8915        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8916        '''
 8917         Tags is a map of key, value pairs.
 8918        '''
 8919
 8920    def __repr__(self):
 8921        return '<sdm.NeptuneIAM ' + \
 8922            'access_key: ' + repr(self.access_key) + ' ' +\
 8923            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8924            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8925            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8926            'healthy: ' + repr(self.healthy) + ' ' +\
 8927            'id: ' + repr(self.id) + ' ' +\
 8928            'name: ' + repr(self.name) + ' ' +\
 8929            'port: ' + repr(self.port) + ' ' +\
 8930            'port_override: ' + repr(self.port_override) + ' ' +\
 8931            'region: ' + repr(self.region) + ' ' +\
 8932            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8933            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8934            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8935            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8936            'tags: ' + repr(self.tags) + ' ' +\
 8937            '>'
 8938
 8939    def to_dict(self):
 8940        return {
 8941            'access_key': self.access_key,
 8942            'bind_interface': self.bind_interface,
 8943            'egress_filter': self.egress_filter,
 8944            'endpoint': self.endpoint,
 8945            'healthy': self.healthy,
 8946            'id': self.id,
 8947            'name': self.name,
 8948            'port': self.port,
 8949            'port_override': self.port_override,
 8950            'region': self.region,
 8951            'role_arn': self.role_arn,
 8952            'role_external_id': self.role_external_id,
 8953            'secret_access_key': self.secret_access_key,
 8954            'secret_store_id': self.secret_store_id,
 8955            'tags': self.tags,
 8956        }
 8957
 8958    @classmethod
 8959    def from_dict(cls, d):
 8960        return cls(
 8961            access_key=d.get('access_key'),
 8962            bind_interface=d.get('bind_interface'),
 8963            egress_filter=d.get('egress_filter'),
 8964            endpoint=d.get('endpoint'),
 8965            healthy=d.get('healthy'),
 8966            id=d.get('id'),
 8967            name=d.get('name'),
 8968            port=d.get('port'),
 8969            port_override=d.get('port_override'),
 8970            region=d.get('region'),
 8971            role_arn=d.get('role_arn'),
 8972            role_external_id=d.get('role_external_id'),
 8973            secret_access_key=d.get('secret_access_key'),
 8974            secret_store_id=d.get('secret_store_id'),
 8975            tags=d.get('tags'),
 8976        )
 8977
 8978
 8979class NodeCreateResponse:
 8980    '''
 8981     NodeCreateResponse reports how the Nodes were created in the system.
 8982    '''
 8983    __slots__ = [
 8984        'meta',
 8985        'node',
 8986        'rate_limit',
 8987        'token',
 8988    ]
 8989
 8990    def __init__(
 8991        self,
 8992        meta=None,
 8993        node=None,
 8994        rate_limit=None,
 8995        token=None,
 8996    ):
 8997        self.meta = meta if meta is not None else None
 8998        '''
 8999         Reserved for future use.
 9000        '''
 9001        self.node = node if node is not None else None
 9002        '''
 9003         The created Node.
 9004        '''
 9005        self.rate_limit = rate_limit if rate_limit is not None else None
 9006        '''
 9007         Rate limit information.
 9008        '''
 9009        self.token = token if token is not None else ''
 9010        '''
 9011         The auth token generated for the Node. The Node will use this token to
 9012         authenticate with the strongDM API.
 9013        '''
 9014
 9015    def __repr__(self):
 9016        return '<sdm.NodeCreateResponse ' + \
 9017            'meta: ' + repr(self.meta) + ' ' +\
 9018            'node: ' + repr(self.node) + ' ' +\
 9019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9020            'token: ' + repr(self.token) + ' ' +\
 9021            '>'
 9022
 9023    def to_dict(self):
 9024        return {
 9025            'meta': self.meta,
 9026            'node': self.node,
 9027            'rate_limit': self.rate_limit,
 9028            'token': self.token,
 9029        }
 9030
 9031    @classmethod
 9032    def from_dict(cls, d):
 9033        return cls(
 9034            meta=d.get('meta'),
 9035            node=d.get('node'),
 9036            rate_limit=d.get('rate_limit'),
 9037            token=d.get('token'),
 9038        )
 9039
 9040
 9041class NodeDeleteResponse:
 9042    '''
 9043     NodeDeleteResponse returns information about a Node that was deleted.
 9044    '''
 9045    __slots__ = [
 9046        'meta',
 9047        'rate_limit',
 9048    ]
 9049
 9050    def __init__(
 9051        self,
 9052        meta=None,
 9053        rate_limit=None,
 9054    ):
 9055        self.meta = meta if meta is not None else None
 9056        '''
 9057         Reserved for future use.
 9058        '''
 9059        self.rate_limit = rate_limit if rate_limit is not None else None
 9060        '''
 9061         Rate limit information.
 9062        '''
 9063
 9064    def __repr__(self):
 9065        return '<sdm.NodeDeleteResponse ' + \
 9066            'meta: ' + repr(self.meta) + ' ' +\
 9067            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9068            '>'
 9069
 9070    def to_dict(self):
 9071        return {
 9072            'meta': self.meta,
 9073            'rate_limit': self.rate_limit,
 9074        }
 9075
 9076    @classmethod
 9077    def from_dict(cls, d):
 9078        return cls(
 9079            meta=d.get('meta'),
 9080            rate_limit=d.get('rate_limit'),
 9081        )
 9082
 9083
 9084class NodeGetResponse:
 9085    '''
 9086     NodeGetResponse returns a requested Node.
 9087    '''
 9088    __slots__ = [
 9089        'meta',
 9090        'node',
 9091        'rate_limit',
 9092    ]
 9093
 9094    def __init__(
 9095        self,
 9096        meta=None,
 9097        node=None,
 9098        rate_limit=None,
 9099    ):
 9100        self.meta = meta if meta is not None else None
 9101        '''
 9102         Reserved for future use.
 9103        '''
 9104        self.node = node if node is not None else None
 9105        '''
 9106         The requested Node.
 9107        '''
 9108        self.rate_limit = rate_limit if rate_limit is not None else None
 9109        '''
 9110         Rate limit information.
 9111        '''
 9112
 9113    def __repr__(self):
 9114        return '<sdm.NodeGetResponse ' + \
 9115            'meta: ' + repr(self.meta) + ' ' +\
 9116            'node: ' + repr(self.node) + ' ' +\
 9117            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9118            '>'
 9119
 9120    def to_dict(self):
 9121        return {
 9122            'meta': self.meta,
 9123            'node': self.node,
 9124            'rate_limit': self.rate_limit,
 9125        }
 9126
 9127    @classmethod
 9128    def from_dict(cls, d):
 9129        return cls(
 9130            meta=d.get('meta'),
 9131            node=d.get('node'),
 9132            rate_limit=d.get('rate_limit'),
 9133        )
 9134
 9135
 9136class NodeUpdateResponse:
 9137    '''
 9138     NodeUpdateResponse returns the fields of a Node after it has been updated by
 9139     a NodeUpdateRequest.
 9140    '''
 9141    __slots__ = [
 9142        'meta',
 9143        'node',
 9144        'rate_limit',
 9145    ]
 9146
 9147    def __init__(
 9148        self,
 9149        meta=None,
 9150        node=None,
 9151        rate_limit=None,
 9152    ):
 9153        self.meta = meta if meta is not None else None
 9154        '''
 9155         Reserved for future use.
 9156        '''
 9157        self.node = node if node is not None else None
 9158        '''
 9159         The updated Node.
 9160        '''
 9161        self.rate_limit = rate_limit if rate_limit is not None else None
 9162        '''
 9163         Rate limit information.
 9164        '''
 9165
 9166    def __repr__(self):
 9167        return '<sdm.NodeUpdateResponse ' + \
 9168            'meta: ' + repr(self.meta) + ' ' +\
 9169            'node: ' + repr(self.node) + ' ' +\
 9170            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9171            '>'
 9172
 9173    def to_dict(self):
 9174        return {
 9175            'meta': self.meta,
 9176            'node': self.node,
 9177            'rate_limit': self.rate_limit,
 9178        }
 9179
 9180    @classmethod
 9181    def from_dict(cls, d):
 9182        return cls(
 9183            meta=d.get('meta'),
 9184            node=d.get('node'),
 9185            rate_limit=d.get('rate_limit'),
 9186        )
 9187
 9188
 9189class Oracle:
 9190    '''
 9191
 9192    '''
 9193    __slots__ = [
 9194        'bind_interface',
 9195        'database',
 9196        'egress_filter',
 9197        'healthy',
 9198        'hostname',
 9199        'id',
 9200        'name',
 9201        'password',
 9202        'port',
 9203        'port_override',
 9204        'secret_store_id',
 9205        'tags',
 9206        'tls_required',
 9207        'username',
 9208    ]
 9209
 9210    def __init__(
 9211        self,
 9212        bind_interface=None,
 9213        database=None,
 9214        egress_filter=None,
 9215        healthy=None,
 9216        hostname=None,
 9217        id=None,
 9218        name=None,
 9219        password=None,
 9220        port=None,
 9221        port_override=None,
 9222        secret_store_id=None,
 9223        tags=None,
 9224        tls_required=None,
 9225        username=None,
 9226    ):
 9227        self.bind_interface = bind_interface if bind_interface is not None else ''
 9228        '''
 9229         Bind interface
 9230        '''
 9231        self.database = database if database is not None else ''
 9232        '''
 9233
 9234        '''
 9235        self.egress_filter = egress_filter if egress_filter is not None else ''
 9236        '''
 9237         A filter applied to the routing logic to pin datasource to nodes.
 9238        '''
 9239        self.healthy = healthy if healthy is not None else False
 9240        '''
 9241         True if the datasource is reachable and the credentials are valid.
 9242        '''
 9243        self.hostname = hostname if hostname is not None else ''
 9244        '''
 9245
 9246        '''
 9247        self.id = id if id is not None else ''
 9248        '''
 9249         Unique identifier of the Resource.
 9250        '''
 9251        self.name = name if name is not None else ''
 9252        '''
 9253         Unique human-readable name of the Resource.
 9254        '''
 9255        self.password = password if password is not None else ''
 9256        '''
 9257
 9258        '''
 9259        self.port = port if port is not None else 0
 9260        '''
 9261
 9262        '''
 9263        self.port_override = port_override if port_override is not None else 0
 9264        '''
 9265
 9266        '''
 9267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9268        '''
 9269         ID of the secret store containing credentials for this resource, if any.
 9270        '''
 9271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9272        '''
 9273         Tags is a map of key, value pairs.
 9274        '''
 9275        self.tls_required = tls_required if tls_required is not None else False
 9276        '''
 9277
 9278        '''
 9279        self.username = username if username is not None else ''
 9280        '''
 9281
 9282        '''
 9283
 9284    def __repr__(self):
 9285        return '<sdm.Oracle ' + \
 9286            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9287            'database: ' + repr(self.database) + ' ' +\
 9288            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9289            'healthy: ' + repr(self.healthy) + ' ' +\
 9290            'hostname: ' + repr(self.hostname) + ' ' +\
 9291            'id: ' + repr(self.id) + ' ' +\
 9292            'name: ' + repr(self.name) + ' ' +\
 9293            'password: ' + repr(self.password) + ' ' +\
 9294            'port: ' + repr(self.port) + ' ' +\
 9295            'port_override: ' + repr(self.port_override) + ' ' +\
 9296            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9297            'tags: ' + repr(self.tags) + ' ' +\
 9298            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9299            'username: ' + repr(self.username) + ' ' +\
 9300            '>'
 9301
 9302    def to_dict(self):
 9303        return {
 9304            'bind_interface': self.bind_interface,
 9305            'database': self.database,
 9306            'egress_filter': self.egress_filter,
 9307            'healthy': self.healthy,
 9308            'hostname': self.hostname,
 9309            'id': self.id,
 9310            'name': self.name,
 9311            'password': self.password,
 9312            'port': self.port,
 9313            'port_override': self.port_override,
 9314            'secret_store_id': self.secret_store_id,
 9315            'tags': self.tags,
 9316            'tls_required': self.tls_required,
 9317            'username': self.username,
 9318        }
 9319
 9320    @classmethod
 9321    def from_dict(cls, d):
 9322        return cls(
 9323            bind_interface=d.get('bind_interface'),
 9324            database=d.get('database'),
 9325            egress_filter=d.get('egress_filter'),
 9326            healthy=d.get('healthy'),
 9327            hostname=d.get('hostname'),
 9328            id=d.get('id'),
 9329            name=d.get('name'),
 9330            password=d.get('password'),
 9331            port=d.get('port'),
 9332            port_override=d.get('port_override'),
 9333            secret_store_id=d.get('secret_store_id'),
 9334            tags=d.get('tags'),
 9335            tls_required=d.get('tls_required'),
 9336            username=d.get('username'),
 9337        )
 9338
 9339
 9340class Postgres:
 9341    '''
 9342
 9343    '''
 9344    __slots__ = [
 9345        'bind_interface',
 9346        'database',
 9347        'egress_filter',
 9348        'healthy',
 9349        'hostname',
 9350        'id',
 9351        'name',
 9352        'override_database',
 9353        'password',
 9354        'port',
 9355        'port_override',
 9356        'secret_store_id',
 9357        'tags',
 9358        'username',
 9359    ]
 9360
 9361    def __init__(
 9362        self,
 9363        bind_interface=None,
 9364        database=None,
 9365        egress_filter=None,
 9366        healthy=None,
 9367        hostname=None,
 9368        id=None,
 9369        name=None,
 9370        override_database=None,
 9371        password=None,
 9372        port=None,
 9373        port_override=None,
 9374        secret_store_id=None,
 9375        tags=None,
 9376        username=None,
 9377    ):
 9378        self.bind_interface = bind_interface if bind_interface is not None else ''
 9379        '''
 9380         Bind interface
 9381        '''
 9382        self.database = database if database is not None else ''
 9383        '''
 9384
 9385        '''
 9386        self.egress_filter = egress_filter if egress_filter is not None else ''
 9387        '''
 9388         A filter applied to the routing logic to pin datasource to nodes.
 9389        '''
 9390        self.healthy = healthy if healthy is not None else False
 9391        '''
 9392         True if the datasource is reachable and the credentials are valid.
 9393        '''
 9394        self.hostname = hostname if hostname is not None else ''
 9395        '''
 9396
 9397        '''
 9398        self.id = id if id is not None else ''
 9399        '''
 9400         Unique identifier of the Resource.
 9401        '''
 9402        self.name = name if name is not None else ''
 9403        '''
 9404         Unique human-readable name of the Resource.
 9405        '''
 9406        self.override_database = override_database if override_database is not None else False
 9407        '''
 9408
 9409        '''
 9410        self.password = password if password is not None else ''
 9411        '''
 9412
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        '''
 9416
 9417        '''
 9418        self.port_override = port_override if port_override is not None else 0
 9419        '''
 9420
 9421        '''
 9422        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9423        '''
 9424         ID of the secret store containing credentials for this resource, if any.
 9425        '''
 9426        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9427        '''
 9428         Tags is a map of key, value pairs.
 9429        '''
 9430        self.username = username if username is not None else ''
 9431        '''
 9432
 9433        '''
 9434
 9435    def __repr__(self):
 9436        return '<sdm.Postgres ' + \
 9437            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9438            'database: ' + repr(self.database) + ' ' +\
 9439            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9440            'healthy: ' + repr(self.healthy) + ' ' +\
 9441            'hostname: ' + repr(self.hostname) + ' ' +\
 9442            'id: ' + repr(self.id) + ' ' +\
 9443            'name: ' + repr(self.name) + ' ' +\
 9444            'override_database: ' + repr(self.override_database) + ' ' +\
 9445            'password: ' + repr(self.password) + ' ' +\
 9446            'port: ' + repr(self.port) + ' ' +\
 9447            'port_override: ' + repr(self.port_override) + ' ' +\
 9448            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9449            'tags: ' + repr(self.tags) + ' ' +\
 9450            'username: ' + repr(self.username) + ' ' +\
 9451            '>'
 9452
 9453    def to_dict(self):
 9454        return {
 9455            'bind_interface': self.bind_interface,
 9456            'database': self.database,
 9457            'egress_filter': self.egress_filter,
 9458            'healthy': self.healthy,
 9459            'hostname': self.hostname,
 9460            'id': self.id,
 9461            'name': self.name,
 9462            'override_database': self.override_database,
 9463            'password': self.password,
 9464            'port': self.port,
 9465            'port_override': self.port_override,
 9466            'secret_store_id': self.secret_store_id,
 9467            'tags': self.tags,
 9468            'username': self.username,
 9469        }
 9470
 9471    @classmethod
 9472    def from_dict(cls, d):
 9473        return cls(
 9474            bind_interface=d.get('bind_interface'),
 9475            database=d.get('database'),
 9476            egress_filter=d.get('egress_filter'),
 9477            healthy=d.get('healthy'),
 9478            hostname=d.get('hostname'),
 9479            id=d.get('id'),
 9480            name=d.get('name'),
 9481            override_database=d.get('override_database'),
 9482            password=d.get('password'),
 9483            port=d.get('port'),
 9484            port_override=d.get('port_override'),
 9485            secret_store_id=d.get('secret_store_id'),
 9486            tags=d.get('tags'),
 9487            username=d.get('username'),
 9488        )
 9489
 9490
 9491class Presto:
 9492    '''
 9493
 9494    '''
 9495    __slots__ = [
 9496        'bind_interface',
 9497        'database',
 9498        'egress_filter',
 9499        'healthy',
 9500        'hostname',
 9501        'id',
 9502        'name',
 9503        'password',
 9504        'port',
 9505        'port_override',
 9506        'secret_store_id',
 9507        'tags',
 9508        'tls_required',
 9509        'username',
 9510    ]
 9511
 9512    def __init__(
 9513        self,
 9514        bind_interface=None,
 9515        database=None,
 9516        egress_filter=None,
 9517        healthy=None,
 9518        hostname=None,
 9519        id=None,
 9520        name=None,
 9521        password=None,
 9522        port=None,
 9523        port_override=None,
 9524        secret_store_id=None,
 9525        tags=None,
 9526        tls_required=None,
 9527        username=None,
 9528    ):
 9529        self.bind_interface = bind_interface if bind_interface is not None else ''
 9530        '''
 9531         Bind interface
 9532        '''
 9533        self.database = database if database is not None else ''
 9534        '''
 9535
 9536        '''
 9537        self.egress_filter = egress_filter if egress_filter is not None else ''
 9538        '''
 9539         A filter applied to the routing logic to pin datasource to nodes.
 9540        '''
 9541        self.healthy = healthy if healthy is not None else False
 9542        '''
 9543         True if the datasource is reachable and the credentials are valid.
 9544        '''
 9545        self.hostname = hostname if hostname is not None else ''
 9546        '''
 9547
 9548        '''
 9549        self.id = id if id is not None else ''
 9550        '''
 9551         Unique identifier of the Resource.
 9552        '''
 9553        self.name = name if name is not None else ''
 9554        '''
 9555         Unique human-readable name of the Resource.
 9556        '''
 9557        self.password = password if password is not None else ''
 9558        '''
 9559
 9560        '''
 9561        self.port = port if port is not None else 0
 9562        '''
 9563
 9564        '''
 9565        self.port_override = port_override if port_override is not None else 0
 9566        '''
 9567
 9568        '''
 9569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9570        '''
 9571         ID of the secret store containing credentials for this resource, if any.
 9572        '''
 9573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9574        '''
 9575         Tags is a map of key, value pairs.
 9576        '''
 9577        self.tls_required = tls_required if tls_required is not None else False
 9578        '''
 9579
 9580        '''
 9581        self.username = username if username is not None else ''
 9582        '''
 9583
 9584        '''
 9585
 9586    def __repr__(self):
 9587        return '<sdm.Presto ' + \
 9588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9589            'database: ' + repr(self.database) + ' ' +\
 9590            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9591            'healthy: ' + repr(self.healthy) + ' ' +\
 9592            'hostname: ' + repr(self.hostname) + ' ' +\
 9593            'id: ' + repr(self.id) + ' ' +\
 9594            'name: ' + repr(self.name) + ' ' +\
 9595            'password: ' + repr(self.password) + ' ' +\
 9596            'port: ' + repr(self.port) + ' ' +\
 9597            'port_override: ' + repr(self.port_override) + ' ' +\
 9598            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9599            'tags: ' + repr(self.tags) + ' ' +\
 9600            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9601            'username: ' + repr(self.username) + ' ' +\
 9602            '>'
 9603
 9604    def to_dict(self):
 9605        return {
 9606            'bind_interface': self.bind_interface,
 9607            'database': self.database,
 9608            'egress_filter': self.egress_filter,
 9609            'healthy': self.healthy,
 9610            'hostname': self.hostname,
 9611            'id': self.id,
 9612            'name': self.name,
 9613            'password': self.password,
 9614            'port': self.port,
 9615            'port_override': self.port_override,
 9616            'secret_store_id': self.secret_store_id,
 9617            'tags': self.tags,
 9618            'tls_required': self.tls_required,
 9619            'username': self.username,
 9620        }
 9621
 9622    @classmethod
 9623    def from_dict(cls, d):
 9624        return cls(
 9625            bind_interface=d.get('bind_interface'),
 9626            database=d.get('database'),
 9627            egress_filter=d.get('egress_filter'),
 9628            healthy=d.get('healthy'),
 9629            hostname=d.get('hostname'),
 9630            id=d.get('id'),
 9631            name=d.get('name'),
 9632            password=d.get('password'),
 9633            port=d.get('port'),
 9634            port_override=d.get('port_override'),
 9635            secret_store_id=d.get('secret_store_id'),
 9636            tags=d.get('tags'),
 9637            tls_required=d.get('tls_required'),
 9638            username=d.get('username'),
 9639        )
 9640
 9641
 9642class RDP:
 9643    '''
 9644
 9645    '''
 9646    __slots__ = [
 9647        'bind_interface',
 9648        'downgrade_nla_connections',
 9649        'egress_filter',
 9650        'healthy',
 9651        'hostname',
 9652        'id',
 9653        'name',
 9654        'password',
 9655        'port',
 9656        'port_override',
 9657        'secret_store_id',
 9658        'tags',
 9659        'username',
 9660    ]
 9661
 9662    def __init__(
 9663        self,
 9664        bind_interface=None,
 9665        downgrade_nla_connections=None,
 9666        egress_filter=None,
 9667        healthy=None,
 9668        hostname=None,
 9669        id=None,
 9670        name=None,
 9671        password=None,
 9672        port=None,
 9673        port_override=None,
 9674        secret_store_id=None,
 9675        tags=None,
 9676        username=None,
 9677    ):
 9678        self.bind_interface = bind_interface if bind_interface is not None else ''
 9679        '''
 9680         Bind interface
 9681        '''
 9682        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9683        '''
 9684
 9685        '''
 9686        self.egress_filter = egress_filter if egress_filter is not None else ''
 9687        '''
 9688         A filter applied to the routing logic to pin datasource to nodes.
 9689        '''
 9690        self.healthy = healthy if healthy is not None else False
 9691        '''
 9692         True if the datasource is reachable and the credentials are valid.
 9693        '''
 9694        self.hostname = hostname if hostname is not None else ''
 9695        '''
 9696
 9697        '''
 9698        self.id = id if id is not None else ''
 9699        '''
 9700         Unique identifier of the Resource.
 9701        '''
 9702        self.name = name if name is not None else ''
 9703        '''
 9704         Unique human-readable name of the Resource.
 9705        '''
 9706        self.password = password if password is not None else ''
 9707        '''
 9708
 9709        '''
 9710        self.port = port if port is not None else 0
 9711        '''
 9712
 9713        '''
 9714        self.port_override = port_override if port_override is not None else 0
 9715        '''
 9716
 9717        '''
 9718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9719        '''
 9720         ID of the secret store containing credentials for this resource, if any.
 9721        '''
 9722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9723        '''
 9724         Tags is a map of key, value pairs.
 9725        '''
 9726        self.username = username if username is not None else ''
 9727        '''
 9728
 9729        '''
 9730
 9731    def __repr__(self):
 9732        return '<sdm.RDP ' + \
 9733            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9734            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9735            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9736            'healthy: ' + repr(self.healthy) + ' ' +\
 9737            'hostname: ' + repr(self.hostname) + ' ' +\
 9738            'id: ' + repr(self.id) + ' ' +\
 9739            'name: ' + repr(self.name) + ' ' +\
 9740            'password: ' + repr(self.password) + ' ' +\
 9741            'port: ' + repr(self.port) + ' ' +\
 9742            'port_override: ' + repr(self.port_override) + ' ' +\
 9743            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9744            'tags: ' + repr(self.tags) + ' ' +\
 9745            'username: ' + repr(self.username) + ' ' +\
 9746            '>'
 9747
 9748    def to_dict(self):
 9749        return {
 9750            'bind_interface': self.bind_interface,
 9751            'downgrade_nla_connections': self.downgrade_nla_connections,
 9752            'egress_filter': self.egress_filter,
 9753            'healthy': self.healthy,
 9754            'hostname': self.hostname,
 9755            'id': self.id,
 9756            'name': self.name,
 9757            'password': self.password,
 9758            'port': self.port,
 9759            'port_override': self.port_override,
 9760            'secret_store_id': self.secret_store_id,
 9761            'tags': self.tags,
 9762            'username': self.username,
 9763        }
 9764
 9765    @classmethod
 9766    def from_dict(cls, d):
 9767        return cls(
 9768            bind_interface=d.get('bind_interface'),
 9769            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9770            egress_filter=d.get('egress_filter'),
 9771            healthy=d.get('healthy'),
 9772            hostname=d.get('hostname'),
 9773            id=d.get('id'),
 9774            name=d.get('name'),
 9775            password=d.get('password'),
 9776            port=d.get('port'),
 9777            port_override=d.get('port_override'),
 9778            secret_store_id=d.get('secret_store_id'),
 9779            tags=d.get('tags'),
 9780            username=d.get('username'),
 9781        )
 9782
 9783
 9784class RabbitMQAMQP091:
 9785    '''
 9786
 9787    '''
 9788    __slots__ = [
 9789        'bind_interface',
 9790        'egress_filter',
 9791        'healthy',
 9792        'hostname',
 9793        'id',
 9794        'name',
 9795        'password',
 9796        'port',
 9797        'port_override',
 9798        'secret_store_id',
 9799        'tags',
 9800        'tls_required',
 9801        'username',
 9802    ]
 9803
 9804    def __init__(
 9805        self,
 9806        bind_interface=None,
 9807        egress_filter=None,
 9808        healthy=None,
 9809        hostname=None,
 9810        id=None,
 9811        name=None,
 9812        password=None,
 9813        port=None,
 9814        port_override=None,
 9815        secret_store_id=None,
 9816        tags=None,
 9817        tls_required=None,
 9818        username=None,
 9819    ):
 9820        self.bind_interface = bind_interface if bind_interface is not None else ''
 9821        '''
 9822         Bind interface
 9823        '''
 9824        self.egress_filter = egress_filter if egress_filter is not None else ''
 9825        '''
 9826         A filter applied to the routing logic to pin datasource to nodes.
 9827        '''
 9828        self.healthy = healthy if healthy is not None else False
 9829        '''
 9830         True if the datasource is reachable and the credentials are valid.
 9831        '''
 9832        self.hostname = hostname if hostname is not None else ''
 9833        '''
 9834
 9835        '''
 9836        self.id = id if id is not None else ''
 9837        '''
 9838         Unique identifier of the Resource.
 9839        '''
 9840        self.name = name if name is not None else ''
 9841        '''
 9842         Unique human-readable name of the Resource.
 9843        '''
 9844        self.password = password if password is not None else ''
 9845        '''
 9846
 9847        '''
 9848        self.port = port if port is not None else 0
 9849        '''
 9850
 9851        '''
 9852        self.port_override = port_override if port_override is not None else 0
 9853        '''
 9854
 9855        '''
 9856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9857        '''
 9858         ID of the secret store containing credentials for this resource, if any.
 9859        '''
 9860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9861        '''
 9862         Tags is a map of key, value pairs.
 9863        '''
 9864        self.tls_required = tls_required if tls_required is not None else False
 9865        '''
 9866
 9867        '''
 9868        self.username = username if username is not None else ''
 9869        '''
 9870
 9871        '''
 9872
 9873    def __repr__(self):
 9874        return '<sdm.RabbitMQAMQP091 ' + \
 9875            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9876            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9877            'healthy: ' + repr(self.healthy) + ' ' +\
 9878            'hostname: ' + repr(self.hostname) + ' ' +\
 9879            'id: ' + repr(self.id) + ' ' +\
 9880            'name: ' + repr(self.name) + ' ' +\
 9881            'password: ' + repr(self.password) + ' ' +\
 9882            'port: ' + repr(self.port) + ' ' +\
 9883            'port_override: ' + repr(self.port_override) + ' ' +\
 9884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9885            'tags: ' + repr(self.tags) + ' ' +\
 9886            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9887            'username: ' + repr(self.username) + ' ' +\
 9888            '>'
 9889
 9890    def to_dict(self):
 9891        return {
 9892            'bind_interface': self.bind_interface,
 9893            'egress_filter': self.egress_filter,
 9894            'healthy': self.healthy,
 9895            'hostname': self.hostname,
 9896            'id': self.id,
 9897            'name': self.name,
 9898            'password': self.password,
 9899            'port': self.port,
 9900            'port_override': self.port_override,
 9901            'secret_store_id': self.secret_store_id,
 9902            'tags': self.tags,
 9903            'tls_required': self.tls_required,
 9904            'username': self.username,
 9905        }
 9906
 9907    @classmethod
 9908    def from_dict(cls, d):
 9909        return cls(
 9910            bind_interface=d.get('bind_interface'),
 9911            egress_filter=d.get('egress_filter'),
 9912            healthy=d.get('healthy'),
 9913            hostname=d.get('hostname'),
 9914            id=d.get('id'),
 9915            name=d.get('name'),
 9916            password=d.get('password'),
 9917            port=d.get('port'),
 9918            port_override=d.get('port_override'),
 9919            secret_store_id=d.get('secret_store_id'),
 9920            tags=d.get('tags'),
 9921            tls_required=d.get('tls_required'),
 9922            username=d.get('username'),
 9923        )
 9924
 9925
 9926class RateLimitMetadata:
 9927    '''
 9928     RateLimitMetadata contains information about remaining requests avaialable
 9929     to the user over some timeframe.
 9930    '''
 9931    __slots__ = [
 9932        'bucket',
 9933        'limit',
 9934        'remaining',
 9935        'reset_at',
 9936    ]
 9937
 9938    def __init__(
 9939        self,
 9940        bucket=None,
 9941        limit=None,
 9942        remaining=None,
 9943        reset_at=None,
 9944    ):
 9945        self.bucket = bucket if bucket is not None else ''
 9946        '''
 9947         The bucket this user/token is associated with, which may be shared between
 9948         multiple users/tokens.
 9949        '''
 9950        self.limit = limit if limit is not None else 0
 9951        '''
 9952         How many total requests the user/token is authorized to make before being
 9953         rate limited.
 9954        '''
 9955        self.remaining = remaining if remaining is not None else 0
 9956        '''
 9957         How many remaining requests out of the limit are still avaialable.
 9958        '''
 9959        self.reset_at = reset_at if reset_at is not None else None
 9960        '''
 9961         The time when remaining will be reset to limit.
 9962        '''
 9963
 9964    def __repr__(self):
 9965        return '<sdm.RateLimitMetadata ' + \
 9966            'bucket: ' + repr(self.bucket) + ' ' +\
 9967            'limit: ' + repr(self.limit) + ' ' +\
 9968            'remaining: ' + repr(self.remaining) + ' ' +\
 9969            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9970            '>'
 9971
 9972    def to_dict(self):
 9973        return {
 9974            'bucket': self.bucket,
 9975            'limit': self.limit,
 9976            'remaining': self.remaining,
 9977            'reset_at': self.reset_at,
 9978        }
 9979
 9980    @classmethod
 9981    def from_dict(cls, d):
 9982        return cls(
 9983            bucket=d.get('bucket'),
 9984            limit=d.get('limit'),
 9985            remaining=d.get('remaining'),
 9986            reset_at=d.get('reset_at'),
 9987        )
 9988
 9989
 9990class RawTCP:
 9991    '''
 9992
 9993    '''
 9994    __slots__ = [
 9995        'bind_interface',
 9996        'egress_filter',
 9997        'healthy',
 9998        'hostname',
 9999        'id',
10000        'name',
10001        'port',
10002        'port_override',
10003        'secret_store_id',
10004        'tags',
10005    ]
10006
10007    def __init__(
10008        self,
10009        bind_interface=None,
10010        egress_filter=None,
10011        healthy=None,
10012        hostname=None,
10013        id=None,
10014        name=None,
10015        port=None,
10016        port_override=None,
10017        secret_store_id=None,
10018        tags=None,
10019    ):
10020        self.bind_interface = bind_interface if bind_interface is not None else ''
10021        '''
10022         Bind interface
10023        '''
10024        self.egress_filter = egress_filter if egress_filter is not None else ''
10025        '''
10026         A filter applied to the routing logic to pin datasource to nodes.
10027        '''
10028        self.healthy = healthy if healthy is not None else False
10029        '''
10030         True if the datasource is reachable and the credentials are valid.
10031        '''
10032        self.hostname = hostname if hostname is not None else ''
10033        '''
10034
10035        '''
10036        self.id = id if id is not None else ''
10037        '''
10038         Unique identifier of the Resource.
10039        '''
10040        self.name = name if name is not None else ''
10041        '''
10042         Unique human-readable name of the Resource.
10043        '''
10044        self.port = port if port is not None else 0
10045        '''
10046
10047        '''
10048        self.port_override = port_override if port_override is not None else 0
10049        '''
10050
10051        '''
10052        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10053        '''
10054         ID of the secret store containing credentials for this resource, if any.
10055        '''
10056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10057        '''
10058         Tags is a map of key, value pairs.
10059        '''
10060
10061    def __repr__(self):
10062        return '<sdm.RawTCP ' + \
10063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10065            'healthy: ' + repr(self.healthy) + ' ' +\
10066            'hostname: ' + repr(self.hostname) + ' ' +\
10067            'id: ' + repr(self.id) + ' ' +\
10068            'name: ' + repr(self.name) + ' ' +\
10069            'port: ' + repr(self.port) + ' ' +\
10070            'port_override: ' + repr(self.port_override) + ' ' +\
10071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10072            'tags: ' + repr(self.tags) + ' ' +\
10073            '>'
10074
10075    def to_dict(self):
10076        return {
10077            'bind_interface': self.bind_interface,
10078            'egress_filter': self.egress_filter,
10079            'healthy': self.healthy,
10080            'hostname': self.hostname,
10081            'id': self.id,
10082            'name': self.name,
10083            'port': self.port,
10084            'port_override': self.port_override,
10085            'secret_store_id': self.secret_store_id,
10086            'tags': self.tags,
10087        }
10088
10089    @classmethod
10090    def from_dict(cls, d):
10091        return cls(
10092            bind_interface=d.get('bind_interface'),
10093            egress_filter=d.get('egress_filter'),
10094            healthy=d.get('healthy'),
10095            hostname=d.get('hostname'),
10096            id=d.get('id'),
10097            name=d.get('name'),
10098            port=d.get('port'),
10099            port_override=d.get('port_override'),
10100            secret_store_id=d.get('secret_store_id'),
10101            tags=d.get('tags'),
10102        )
10103
10104
10105class Redis:
10106    '''
10107
10108    '''
10109    __slots__ = [
10110        'bind_interface',
10111        'egress_filter',
10112        'healthy',
10113        'hostname',
10114        'id',
10115        'name',
10116        'password',
10117        'port',
10118        'port_override',
10119        'secret_store_id',
10120        'tags',
10121    ]
10122
10123    def __init__(
10124        self,
10125        bind_interface=None,
10126        egress_filter=None,
10127        healthy=None,
10128        hostname=None,
10129        id=None,
10130        name=None,
10131        password=None,
10132        port=None,
10133        port_override=None,
10134        secret_store_id=None,
10135        tags=None,
10136    ):
10137        self.bind_interface = bind_interface if bind_interface is not None else ''
10138        '''
10139         Bind interface
10140        '''
10141        self.egress_filter = egress_filter if egress_filter is not None else ''
10142        '''
10143         A filter applied to the routing logic to pin datasource to nodes.
10144        '''
10145        self.healthy = healthy if healthy is not None else False
10146        '''
10147         True if the datasource is reachable and the credentials are valid.
10148        '''
10149        self.hostname = hostname if hostname is not None else ''
10150        '''
10151
10152        '''
10153        self.id = id if id is not None else ''
10154        '''
10155         Unique identifier of the Resource.
10156        '''
10157        self.name = name if name is not None else ''
10158        '''
10159         Unique human-readable name of the Resource.
10160        '''
10161        self.password = password if password is not None else ''
10162        '''
10163
10164        '''
10165        self.port = port if port is not None else 0
10166        '''
10167
10168        '''
10169        self.port_override = port_override if port_override is not None else 0
10170        '''
10171
10172        '''
10173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10174        '''
10175         ID of the secret store containing credentials for this resource, if any.
10176        '''
10177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10178        '''
10179         Tags is a map of key, value pairs.
10180        '''
10181
10182    def __repr__(self):
10183        return '<sdm.Redis ' + \
10184            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10186            'healthy: ' + repr(self.healthy) + ' ' +\
10187            'hostname: ' + repr(self.hostname) + ' ' +\
10188            'id: ' + repr(self.id) + ' ' +\
10189            'name: ' + repr(self.name) + ' ' +\
10190            'password: ' + repr(self.password) + ' ' +\
10191            'port: ' + repr(self.port) + ' ' +\
10192            'port_override: ' + repr(self.port_override) + ' ' +\
10193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10194            'tags: ' + repr(self.tags) + ' ' +\
10195            '>'
10196
10197    def to_dict(self):
10198        return {
10199            'bind_interface': self.bind_interface,
10200            'egress_filter': self.egress_filter,
10201            'healthy': self.healthy,
10202            'hostname': self.hostname,
10203            'id': self.id,
10204            'name': self.name,
10205            'password': self.password,
10206            'port': self.port,
10207            'port_override': self.port_override,
10208            'secret_store_id': self.secret_store_id,
10209            'tags': self.tags,
10210        }
10211
10212    @classmethod
10213    def from_dict(cls, d):
10214        return cls(
10215            bind_interface=d.get('bind_interface'),
10216            egress_filter=d.get('egress_filter'),
10217            healthy=d.get('healthy'),
10218            hostname=d.get('hostname'),
10219            id=d.get('id'),
10220            name=d.get('name'),
10221            password=d.get('password'),
10222            port=d.get('port'),
10223            port_override=d.get('port_override'),
10224            secret_store_id=d.get('secret_store_id'),
10225            tags=d.get('tags'),
10226        )
10227
10228
10229class Redshift:
10230    '''
10231
10232    '''
10233    __slots__ = [
10234        'bind_interface',
10235        'database',
10236        'egress_filter',
10237        'healthy',
10238        'hostname',
10239        'id',
10240        'name',
10241        'override_database',
10242        'password',
10243        'port',
10244        'port_override',
10245        'secret_store_id',
10246        'tags',
10247        'username',
10248    ]
10249
10250    def __init__(
10251        self,
10252        bind_interface=None,
10253        database=None,
10254        egress_filter=None,
10255        healthy=None,
10256        hostname=None,
10257        id=None,
10258        name=None,
10259        override_database=None,
10260        password=None,
10261        port=None,
10262        port_override=None,
10263        secret_store_id=None,
10264        tags=None,
10265        username=None,
10266    ):
10267        self.bind_interface = bind_interface if bind_interface is not None else ''
10268        '''
10269         Bind interface
10270        '''
10271        self.database = database if database is not None else ''
10272        '''
10273
10274        '''
10275        self.egress_filter = egress_filter if egress_filter is not None else ''
10276        '''
10277         A filter applied to the routing logic to pin datasource to nodes.
10278        '''
10279        self.healthy = healthy if healthy is not None else False
10280        '''
10281         True if the datasource is reachable and the credentials are valid.
10282        '''
10283        self.hostname = hostname if hostname is not None else ''
10284        '''
10285
10286        '''
10287        self.id = id if id is not None else ''
10288        '''
10289         Unique identifier of the Resource.
10290        '''
10291        self.name = name if name is not None else ''
10292        '''
10293         Unique human-readable name of the Resource.
10294        '''
10295        self.override_database = override_database if override_database is not None else False
10296        '''
10297
10298        '''
10299        self.password = password if password is not None else ''
10300        '''
10301
10302        '''
10303        self.port = port if port is not None else 0
10304        '''
10305
10306        '''
10307        self.port_override = port_override if port_override is not None else 0
10308        '''
10309
10310        '''
10311        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10312        '''
10313         ID of the secret store containing credentials for this resource, if any.
10314        '''
10315        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10316        '''
10317         Tags is a map of key, value pairs.
10318        '''
10319        self.username = username if username is not None else ''
10320        '''
10321
10322        '''
10323
10324    def __repr__(self):
10325        return '<sdm.Redshift ' + \
10326            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10327            'database: ' + repr(self.database) + ' ' +\
10328            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10329            'healthy: ' + repr(self.healthy) + ' ' +\
10330            'hostname: ' + repr(self.hostname) + ' ' +\
10331            'id: ' + repr(self.id) + ' ' +\
10332            'name: ' + repr(self.name) + ' ' +\
10333            'override_database: ' + repr(self.override_database) + ' ' +\
10334            'password: ' + repr(self.password) + ' ' +\
10335            'port: ' + repr(self.port) + ' ' +\
10336            'port_override: ' + repr(self.port_override) + ' ' +\
10337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10338            'tags: ' + repr(self.tags) + ' ' +\
10339            'username: ' + repr(self.username) + ' ' +\
10340            '>'
10341
10342    def to_dict(self):
10343        return {
10344            'bind_interface': self.bind_interface,
10345            'database': self.database,
10346            'egress_filter': self.egress_filter,
10347            'healthy': self.healthy,
10348            'hostname': self.hostname,
10349            'id': self.id,
10350            'name': self.name,
10351            'override_database': self.override_database,
10352            'password': self.password,
10353            'port': self.port,
10354            'port_override': self.port_override,
10355            'secret_store_id': self.secret_store_id,
10356            'tags': self.tags,
10357            'username': self.username,
10358        }
10359
10360    @classmethod
10361    def from_dict(cls, d):
10362        return cls(
10363            bind_interface=d.get('bind_interface'),
10364            database=d.get('database'),
10365            egress_filter=d.get('egress_filter'),
10366            healthy=d.get('healthy'),
10367            hostname=d.get('hostname'),
10368            id=d.get('id'),
10369            name=d.get('name'),
10370            override_database=d.get('override_database'),
10371            password=d.get('password'),
10372            port=d.get('port'),
10373            port_override=d.get('port_override'),
10374            secret_store_id=d.get('secret_store_id'),
10375            tags=d.get('tags'),
10376            username=d.get('username'),
10377        )
10378
10379
10380class Relay:
10381    '''
10382     Relay represents a StrongDM CLI installation running in relay mode.
10383    '''
10384    __slots__ = [
10385        'gateway_filter',
10386        'id',
10387        'name',
10388        'state',
10389        'tags',
10390    ]
10391
10392    def __init__(
10393        self,
10394        gateway_filter=None,
10395        id=None,
10396        name=None,
10397        state=None,
10398        tags=None,
10399    ):
10400        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10401        '''
10402         GatewayFilter can be used to restrict the peering between relays and
10403         gateways.
10404        '''
10405        self.id = id if id is not None else ''
10406        '''
10407         Unique identifier of the Relay.
10408        '''
10409        self.name = name if name is not None else ''
10410        '''
10411         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10412        '''
10413        self.state = state if state is not None else ''
10414        '''
10415         The current state of the relay. One of: "new", "verifying_restart",
10416         "awaiting_restart", "restarting", "started", "stopped", "dead",
10417         "unknown".
10418        '''
10419        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10420        '''
10421         Tags is a map of key, value pairs.
10422        '''
10423
10424    def __repr__(self):
10425        return '<sdm.Relay ' + \
10426            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10427            'id: ' + repr(self.id) + ' ' +\
10428            'name: ' + repr(self.name) + ' ' +\
10429            'state: ' + repr(self.state) + ' ' +\
10430            'tags: ' + repr(self.tags) + ' ' +\
10431            '>'
10432
10433    def to_dict(self):
10434        return {
10435            'gateway_filter': self.gateway_filter,
10436            'id': self.id,
10437            'name': self.name,
10438            'state': self.state,
10439            'tags': self.tags,
10440        }
10441
10442    @classmethod
10443    def from_dict(cls, d):
10444        return cls(
10445            gateway_filter=d.get('gateway_filter'),
10446            id=d.get('id'),
10447            name=d.get('name'),
10448            state=d.get('state'),
10449            tags=d.get('tags'),
10450        )
10451
10452
10453class RemoteIdentity:
10454    '''
10455     RemoteIdentities define the username to be used for a specific account
10456     when connecting to a remote resource using that group.
10457    '''
10458    __slots__ = [
10459        'account_id',
10460        'id',
10461        'remote_identity_group_id',
10462        'username',
10463    ]
10464
10465    def __init__(
10466        self,
10467        account_id=None,
10468        id=None,
10469        remote_identity_group_id=None,
10470        username=None,
10471    ):
10472        self.account_id = account_id if account_id is not None else ''
10473        '''
10474         The account for this remote identity.
10475        '''
10476        self.id = id if id is not None else ''
10477        '''
10478         Unique identifier of the RemoteIdentity.
10479        '''
10480        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10481        '''
10482         The remote identity group.
10483        '''
10484        self.username = username if username is not None else ''
10485        '''
10486         The username to be used as the remote identity for this account.
10487        '''
10488
10489    def __repr__(self):
10490        return '<sdm.RemoteIdentity ' + \
10491            'account_id: ' + repr(self.account_id) + ' ' +\
10492            'id: ' + repr(self.id) + ' ' +\
10493            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10494            'username: ' + repr(self.username) + ' ' +\
10495            '>'
10496
10497    def to_dict(self):
10498        return {
10499            'account_id': self.account_id,
10500            'id': self.id,
10501            'remote_identity_group_id': self.remote_identity_group_id,
10502            'username': self.username,
10503        }
10504
10505    @classmethod
10506    def from_dict(cls, d):
10507        return cls(
10508            account_id=d.get('account_id'),
10509            id=d.get('id'),
10510            remote_identity_group_id=d.get('remote_identity_group_id'),
10511            username=d.get('username'),
10512        )
10513
10514
10515class RemoteIdentityCreateResponse:
10516    '''
10517     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10518    '''
10519    __slots__ = [
10520        'meta',
10521        'rate_limit',
10522        'remote_identity',
10523    ]
10524
10525    def __init__(
10526        self,
10527        meta=None,
10528        rate_limit=None,
10529        remote_identity=None,
10530    ):
10531        self.meta = meta if meta is not None else None
10532        '''
10533         Reserved for future use.
10534        '''
10535        self.rate_limit = rate_limit if rate_limit is not None else None
10536        '''
10537         Rate limit information.
10538        '''
10539        self.remote_identity = remote_identity if remote_identity is not None else None
10540        '''
10541         The created RemoteIdentity.
10542        '''
10543
10544    def __repr__(self):
10545        return '<sdm.RemoteIdentityCreateResponse ' + \
10546            'meta: ' + repr(self.meta) + ' ' +\
10547            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10548            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10549            '>'
10550
10551    def to_dict(self):
10552        return {
10553            'meta': self.meta,
10554            'rate_limit': self.rate_limit,
10555            'remote_identity': self.remote_identity,
10556        }
10557
10558    @classmethod
10559    def from_dict(cls, d):
10560        return cls(
10561            meta=d.get('meta'),
10562            rate_limit=d.get('rate_limit'),
10563            remote_identity=d.get('remote_identity'),
10564        )
10565
10566
10567class RemoteIdentityDeleteResponse:
10568    '''
10569     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10570    '''
10571    __slots__ = [
10572        'meta',
10573        'rate_limit',
10574    ]
10575
10576    def __init__(
10577        self,
10578        meta=None,
10579        rate_limit=None,
10580    ):
10581        self.meta = meta if meta is not None else None
10582        '''
10583         Reserved for future use.
10584        '''
10585        self.rate_limit = rate_limit if rate_limit is not None else None
10586        '''
10587         Rate limit information.
10588        '''
10589
10590    def __repr__(self):
10591        return '<sdm.RemoteIdentityDeleteResponse ' + \
10592            'meta: ' + repr(self.meta) + ' ' +\
10593            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10594            '>'
10595
10596    def to_dict(self):
10597        return {
10598            'meta': self.meta,
10599            'rate_limit': self.rate_limit,
10600        }
10601
10602    @classmethod
10603    def from_dict(cls, d):
10604        return cls(
10605            meta=d.get('meta'),
10606            rate_limit=d.get('rate_limit'),
10607        )
10608
10609
10610class RemoteIdentityGetResponse:
10611    '''
10612     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10613    '''
10614    __slots__ = [
10615        'meta',
10616        'rate_limit',
10617        'remote_identity',
10618    ]
10619
10620    def __init__(
10621        self,
10622        meta=None,
10623        rate_limit=None,
10624        remote_identity=None,
10625    ):
10626        self.meta = meta if meta is not None else None
10627        '''
10628         Reserved for future use.
10629        '''
10630        self.rate_limit = rate_limit if rate_limit is not None else None
10631        '''
10632         Rate limit information.
10633        '''
10634        self.remote_identity = remote_identity if remote_identity is not None else None
10635        '''
10636         The requested RemoteIdentity.
10637        '''
10638
10639    def __repr__(self):
10640        return '<sdm.RemoteIdentityGetResponse ' + \
10641            'meta: ' + repr(self.meta) + ' ' +\
10642            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10643            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10644            '>'
10645
10646    def to_dict(self):
10647        return {
10648            'meta': self.meta,
10649            'rate_limit': self.rate_limit,
10650            'remote_identity': self.remote_identity,
10651        }
10652
10653    @classmethod
10654    def from_dict(cls, d):
10655        return cls(
10656            meta=d.get('meta'),
10657            rate_limit=d.get('rate_limit'),
10658            remote_identity=d.get('remote_identity'),
10659        )
10660
10661
10662class RemoteIdentityGroup:
10663    '''
10664     A RemoteIdentityGroup defines a group of remote identities.
10665    '''
10666    __slots__ = [
10667        'id',
10668        'name',
10669    ]
10670
10671    def __init__(
10672        self,
10673        id=None,
10674        name=None,
10675    ):
10676        self.id = id if id is not None else ''
10677        '''
10678         Unique identifier of the RemoteIdentityGroup.
10679        '''
10680        self.name = name if name is not None else ''
10681        '''
10682         Unique human-readable name of the RemoteIdentityGroup.
10683        '''
10684
10685    def __repr__(self):
10686        return '<sdm.RemoteIdentityGroup ' + \
10687            'id: ' + repr(self.id) + ' ' +\
10688            'name: ' + repr(self.name) + ' ' +\
10689            '>'
10690
10691    def to_dict(self):
10692        return {
10693            'id': self.id,
10694            'name': self.name,
10695        }
10696
10697    @classmethod
10698    def from_dict(cls, d):
10699        return cls(
10700            id=d.get('id'),
10701            name=d.get('name'),
10702        )
10703
10704
10705class RemoteIdentityGroupGetResponse:
10706    '''
10707     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10708    '''
10709    __slots__ = [
10710        'meta',
10711        'rate_limit',
10712        'remote_identity_group',
10713    ]
10714
10715    def __init__(
10716        self,
10717        meta=None,
10718        rate_limit=None,
10719        remote_identity_group=None,
10720    ):
10721        self.meta = meta if meta is not None else None
10722        '''
10723         Reserved for future use.
10724        '''
10725        self.rate_limit = rate_limit if rate_limit is not None else None
10726        '''
10727         Rate limit information.
10728        '''
10729        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10730        '''
10731         The requested RemoteIdentityGroup.
10732        '''
10733
10734    def __repr__(self):
10735        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10736            'meta: ' + repr(self.meta) + ' ' +\
10737            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10738            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10739            '>'
10740
10741    def to_dict(self):
10742        return {
10743            'meta': self.meta,
10744            'rate_limit': self.rate_limit,
10745            'remote_identity_group': self.remote_identity_group,
10746        }
10747
10748    @classmethod
10749    def from_dict(cls, d):
10750        return cls(
10751            meta=d.get('meta'),
10752            rate_limit=d.get('rate_limit'),
10753            remote_identity_group=d.get('remote_identity_group'),
10754        )
10755
10756
10757class RemoteIdentityUpdateResponse:
10758    '''
10759     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10760     a RemoteIdentityUpdateRequest.
10761    '''
10762    __slots__ = [
10763        'meta',
10764        'rate_limit',
10765        'remote_identity',
10766    ]
10767
10768    def __init__(
10769        self,
10770        meta=None,
10771        rate_limit=None,
10772        remote_identity=None,
10773    ):
10774        self.meta = meta if meta is not None else None
10775        '''
10776         Reserved for future use.
10777        '''
10778        self.rate_limit = rate_limit if rate_limit is not None else None
10779        '''
10780         Rate limit information.
10781        '''
10782        self.remote_identity = remote_identity if remote_identity is not None else None
10783        '''
10784         The updated RemoteIdentity.
10785        '''
10786
10787    def __repr__(self):
10788        return '<sdm.RemoteIdentityUpdateResponse ' + \
10789            'meta: ' + repr(self.meta) + ' ' +\
10790            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10791            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10792            '>'
10793
10794    def to_dict(self):
10795        return {
10796            'meta': self.meta,
10797            'rate_limit': self.rate_limit,
10798            'remote_identity': self.remote_identity,
10799        }
10800
10801    @classmethod
10802    def from_dict(cls, d):
10803        return cls(
10804            meta=d.get('meta'),
10805            rate_limit=d.get('rate_limit'),
10806            remote_identity=d.get('remote_identity'),
10807        )
10808
10809
10810class ResourceCreateResponse:
10811    '''
10812     ResourceCreateResponse reports how the Resources were created in the system.
10813    '''
10814    __slots__ = [
10815        'meta',
10816        'rate_limit',
10817        'resource',
10818    ]
10819
10820    def __init__(
10821        self,
10822        meta=None,
10823        rate_limit=None,
10824        resource=None,
10825    ):
10826        self.meta = meta if meta is not None else None
10827        '''
10828         Reserved for future use.
10829        '''
10830        self.rate_limit = rate_limit if rate_limit is not None else None
10831        '''
10832         Rate limit information.
10833        '''
10834        self.resource = resource if resource is not None else None
10835        '''
10836         The created Resource.
10837        '''
10838
10839    def __repr__(self):
10840        return '<sdm.ResourceCreateResponse ' + \
10841            'meta: ' + repr(self.meta) + ' ' +\
10842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10843            'resource: ' + repr(self.resource) + ' ' +\
10844            '>'
10845
10846    def to_dict(self):
10847        return {
10848            'meta': self.meta,
10849            'rate_limit': self.rate_limit,
10850            'resource': self.resource,
10851        }
10852
10853    @classmethod
10854    def from_dict(cls, d):
10855        return cls(
10856            meta=d.get('meta'),
10857            rate_limit=d.get('rate_limit'),
10858            resource=d.get('resource'),
10859        )
10860
10861
10862class ResourceDeleteResponse:
10863    '''
10864     ResourceDeleteResponse returns information about a Resource that was deleted.
10865    '''
10866    __slots__ = [
10867        'meta',
10868        'rate_limit',
10869    ]
10870
10871    def __init__(
10872        self,
10873        meta=None,
10874        rate_limit=None,
10875    ):
10876        self.meta = meta if meta is not None else None
10877        '''
10878         Reserved for future use.
10879        '''
10880        self.rate_limit = rate_limit if rate_limit is not None else None
10881        '''
10882         Rate limit information.
10883        '''
10884
10885    def __repr__(self):
10886        return '<sdm.ResourceDeleteResponse ' + \
10887            'meta: ' + repr(self.meta) + ' ' +\
10888            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10889            '>'
10890
10891    def to_dict(self):
10892        return {
10893            'meta': self.meta,
10894            'rate_limit': self.rate_limit,
10895        }
10896
10897    @classmethod
10898    def from_dict(cls, d):
10899        return cls(
10900            meta=d.get('meta'),
10901            rate_limit=d.get('rate_limit'),
10902        )
10903
10904
10905class ResourceGetResponse:
10906    '''
10907     ResourceGetResponse returns a requested Resource.
10908    '''
10909    __slots__ = [
10910        'meta',
10911        'rate_limit',
10912        'resource',
10913    ]
10914
10915    def __init__(
10916        self,
10917        meta=None,
10918        rate_limit=None,
10919        resource=None,
10920    ):
10921        self.meta = meta if meta is not None else None
10922        '''
10923         Reserved for future use.
10924        '''
10925        self.rate_limit = rate_limit if rate_limit is not None else None
10926        '''
10927         Rate limit information.
10928        '''
10929        self.resource = resource if resource is not None else None
10930        '''
10931         The requested Resource.
10932        '''
10933
10934    def __repr__(self):
10935        return '<sdm.ResourceGetResponse ' + \
10936            'meta: ' + repr(self.meta) + ' ' +\
10937            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10938            'resource: ' + repr(self.resource) + ' ' +\
10939            '>'
10940
10941    def to_dict(self):
10942        return {
10943            'meta': self.meta,
10944            'rate_limit': self.rate_limit,
10945            'resource': self.resource,
10946        }
10947
10948    @classmethod
10949    def from_dict(cls, d):
10950        return cls(
10951            meta=d.get('meta'),
10952            rate_limit=d.get('rate_limit'),
10953            resource=d.get('resource'),
10954        )
10955
10956
10957class ResourceUpdateResponse:
10958    '''
10959     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10960     a ResourceUpdateRequest.
10961    '''
10962    __slots__ = [
10963        'meta',
10964        'rate_limit',
10965        'resource',
10966    ]
10967
10968    def __init__(
10969        self,
10970        meta=None,
10971        rate_limit=None,
10972        resource=None,
10973    ):
10974        self.meta = meta if meta is not None else None
10975        '''
10976         Reserved for future use.
10977        '''
10978        self.rate_limit = rate_limit if rate_limit is not None else None
10979        '''
10980         Rate limit information.
10981        '''
10982        self.resource = resource if resource is not None else None
10983        '''
10984         The updated Resource.
10985        '''
10986
10987    def __repr__(self):
10988        return '<sdm.ResourceUpdateResponse ' + \
10989            'meta: ' + repr(self.meta) + ' ' +\
10990            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10991            'resource: ' + repr(self.resource) + ' ' +\
10992            '>'
10993
10994    def to_dict(self):
10995        return {
10996            'meta': self.meta,
10997            'rate_limit': self.rate_limit,
10998            'resource': self.resource,
10999        }
11000
11001    @classmethod
11002    def from_dict(cls, d):
11003        return cls(
11004            meta=d.get('meta'),
11005            rate_limit=d.get('rate_limit'),
11006            resource=d.get('resource'),
11007        )
11008
11009
11010class Role:
11011    '''
11012     A Role has a list of access rules which determine which Resources the members
11013     of the Role have access to. An Account can be a member of multiple Roles via
11014     AccountAttachments.
11015    '''
11016    __slots__ = [
11017        'access_rules',
11018        'composite',
11019        'id',
11020        'name',
11021        'tags',
11022    ]
11023
11024    def __init__(
11025        self,
11026        access_rules=None,
11027        composite=None,
11028        id=None,
11029        name=None,
11030        tags=None,
11031    ):
11032        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11033        )
11034        '''
11035         AccessRules is a list of access rules defining the resources this Role has access to.
11036        '''
11037        self.composite = composite if composite is not None else False
11038        '''
11039         Composite is true if the Role is a composite role.
11040         
11041         Deprecated: composite roles are deprecated, use multi-role via
11042         AccountAttachments instead.
11043        '''
11044        self.id = id if id is not None else ''
11045        '''
11046         Unique identifier of the Role.
11047        '''
11048        self.name = name if name is not None else ''
11049        '''
11050         Unique human-readable name of the Role.
11051        '''
11052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11053        '''
11054         Tags is a map of key, value pairs.
11055        '''
11056
11057    def __repr__(self):
11058        return '<sdm.Role ' + \
11059            'access_rules: ' + repr(self.access_rules) + ' ' +\
11060            'composite: ' + repr(self.composite) + ' ' +\
11061            'id: ' + repr(self.id) + ' ' +\
11062            'name: ' + repr(self.name) + ' ' +\
11063            'tags: ' + repr(self.tags) + ' ' +\
11064            '>'
11065
11066    def to_dict(self):
11067        return {
11068            'access_rules': self.access_rules,
11069            'composite': self.composite,
11070            'id': self.id,
11071            'name': self.name,
11072            'tags': self.tags,
11073        }
11074
11075    @classmethod
11076    def from_dict(cls, d):
11077        return cls(
11078            access_rules=d.get('access_rules'),
11079            composite=d.get('composite'),
11080            id=d.get('id'),
11081            name=d.get('name'),
11082            tags=d.get('tags'),
11083        )
11084
11085
11086class RoleAttachment:
11087    '''
11088     A RoleAttachment assigns a role to a composite role.
11089     
11090     Deprecated: use multi-role via AccountAttachments instead.
11091    '''
11092    __slots__ = [
11093        'attached_role_id',
11094        'composite_role_id',
11095        'id',
11096    ]
11097
11098    def __init__(
11099        self,
11100        attached_role_id=None,
11101        composite_role_id=None,
11102        id=None,
11103    ):
11104        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11105        '''
11106         The id of the attached role of this RoleAttachment.
11107        '''
11108        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11109        '''
11110         The id of the composite role of this RoleAttachment.
11111        '''
11112        self.id = id if id is not None else ''
11113        '''
11114         Unique identifier of the RoleAttachment.
11115        '''
11116
11117    def __repr__(self):
11118        return '<sdm.RoleAttachment ' + \
11119            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
11120            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
11121            'id: ' + repr(self.id) + ' ' +\
11122            '>'
11123
11124    def to_dict(self):
11125        return {
11126            'attached_role_id': self.attached_role_id,
11127            'composite_role_id': self.composite_role_id,
11128            'id': self.id,
11129        }
11130
11131    @classmethod
11132    def from_dict(cls, d):
11133        return cls(
11134            attached_role_id=d.get('attached_role_id'),
11135            composite_role_id=d.get('composite_role_id'),
11136            id=d.get('id'),
11137        )
11138
11139
11140class RoleAttachmentCreateResponse:
11141    '''
11142     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
11143     
11144     Deprecated: use multi-role via AccountAttachments instead.
11145    '''
11146    __slots__ = [
11147        'meta',
11148        'rate_limit',
11149        'role_attachment',
11150    ]
11151
11152    def __init__(
11153        self,
11154        meta=None,
11155        rate_limit=None,
11156        role_attachment=None,
11157    ):
11158        self.meta = meta if meta is not None else None
11159        '''
11160         Reserved for future use.
11161        '''
11162        self.rate_limit = rate_limit if rate_limit is not None else None
11163        '''
11164         Rate limit information.
11165        '''
11166        self.role_attachment = role_attachment if role_attachment is not None else None
11167        '''
11168         The created RoleAttachment.
11169        '''
11170
11171    def __repr__(self):
11172        return '<sdm.RoleAttachmentCreateResponse ' + \
11173            'meta: ' + repr(self.meta) + ' ' +\
11174            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11175            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11176            '>'
11177
11178    def to_dict(self):
11179        return {
11180            'meta': self.meta,
11181            'rate_limit': self.rate_limit,
11182            'role_attachment': self.role_attachment,
11183        }
11184
11185    @classmethod
11186    def from_dict(cls, d):
11187        return cls(
11188            meta=d.get('meta'),
11189            rate_limit=d.get('rate_limit'),
11190            role_attachment=d.get('role_attachment'),
11191        )
11192
11193
11194class RoleAttachmentDeleteResponse:
11195    '''
11196     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
11197     
11198     Deprecated: use multi-role via AccountAttachments instead.
11199    '''
11200    __slots__ = [
11201        'meta',
11202        'rate_limit',
11203    ]
11204
11205    def __init__(
11206        self,
11207        meta=None,
11208        rate_limit=None,
11209    ):
11210        self.meta = meta if meta is not None else None
11211        '''
11212         Reserved for future use.
11213        '''
11214        self.rate_limit = rate_limit if rate_limit is not None else None
11215        '''
11216         Rate limit information.
11217        '''
11218
11219    def __repr__(self):
11220        return '<sdm.RoleAttachmentDeleteResponse ' + \
11221            'meta: ' + repr(self.meta) + ' ' +\
11222            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11223            '>'
11224
11225    def to_dict(self):
11226        return {
11227            'meta': self.meta,
11228            'rate_limit': self.rate_limit,
11229        }
11230
11231    @classmethod
11232    def from_dict(cls, d):
11233        return cls(
11234            meta=d.get('meta'),
11235            rate_limit=d.get('rate_limit'),
11236        )
11237
11238
11239class RoleAttachmentGetResponse:
11240    '''
11241     RoleAttachmentGetResponse returns a requested RoleAttachment.
11242     
11243     Deprecated: use multi-role via AccountAttachments instead.
11244    '''
11245    __slots__ = [
11246        'meta',
11247        'rate_limit',
11248        'role_attachment',
11249    ]
11250
11251    def __init__(
11252        self,
11253        meta=None,
11254        rate_limit=None,
11255        role_attachment=None,
11256    ):
11257        self.meta = meta if meta is not None else None
11258        '''
11259         Reserved for future use.
11260        '''
11261        self.rate_limit = rate_limit if rate_limit is not None else None
11262        '''
11263         Rate limit information.
11264        '''
11265        self.role_attachment = role_attachment if role_attachment is not None else None
11266        '''
11267         The requested RoleAttachment.
11268        '''
11269
11270    def __repr__(self):
11271        return '<sdm.RoleAttachmentGetResponse ' + \
11272            'meta: ' + repr(self.meta) + ' ' +\
11273            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11274            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11275            '>'
11276
11277    def to_dict(self):
11278        return {
11279            'meta': self.meta,
11280            'rate_limit': self.rate_limit,
11281            'role_attachment': self.role_attachment,
11282        }
11283
11284    @classmethod
11285    def from_dict(cls, d):
11286        return cls(
11287            meta=d.get('meta'),
11288            rate_limit=d.get('rate_limit'),
11289            role_attachment=d.get('role_attachment'),
11290        )
11291
11292
11293class RoleCreateResponse:
11294    '''
11295     RoleCreateResponse reports how the Roles were created in the system. It can
11296     communicate partial successes or failures.
11297    '''
11298    __slots__ = [
11299        'meta',
11300        'rate_limit',
11301        'role',
11302    ]
11303
11304    def __init__(
11305        self,
11306        meta=None,
11307        rate_limit=None,
11308        role=None,
11309    ):
11310        self.meta = meta if meta is not None else None
11311        '''
11312         Reserved for future use.
11313        '''
11314        self.rate_limit = rate_limit if rate_limit is not None else None
11315        '''
11316         Rate limit information.
11317        '''
11318        self.role = role if role is not None else None
11319        '''
11320         The created Role.
11321        '''
11322
11323    def __repr__(self):
11324        return '<sdm.RoleCreateResponse ' + \
11325            'meta: ' + repr(self.meta) + ' ' +\
11326            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11327            'role: ' + repr(self.role) + ' ' +\
11328            '>'
11329
11330    def to_dict(self):
11331        return {
11332            'meta': self.meta,
11333            'rate_limit': self.rate_limit,
11334            'role': self.role,
11335        }
11336
11337    @classmethod
11338    def from_dict(cls, d):
11339        return cls(
11340            meta=d.get('meta'),
11341            rate_limit=d.get('rate_limit'),
11342            role=d.get('role'),
11343        )
11344
11345
11346class RoleDeleteResponse:
11347    '''
11348     RoleDeleteResponse returns information about a Role that was deleted.
11349    '''
11350    __slots__ = [
11351        'meta',
11352        'rate_limit',
11353    ]
11354
11355    def __init__(
11356        self,
11357        meta=None,
11358        rate_limit=None,
11359    ):
11360        self.meta = meta if meta is not None else None
11361        '''
11362         Reserved for future use.
11363        '''
11364        self.rate_limit = rate_limit if rate_limit is not None else None
11365        '''
11366         Rate limit information.
11367        '''
11368
11369    def __repr__(self):
11370        return '<sdm.RoleDeleteResponse ' + \
11371            'meta: ' + repr(self.meta) + ' ' +\
11372            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11373            '>'
11374
11375    def to_dict(self):
11376        return {
11377            'meta': self.meta,
11378            'rate_limit': self.rate_limit,
11379        }
11380
11381    @classmethod
11382    def from_dict(cls, d):
11383        return cls(
11384            meta=d.get('meta'),
11385            rate_limit=d.get('rate_limit'),
11386        )
11387
11388
11389class RoleGetResponse:
11390    '''
11391     RoleGetResponse returns a requested Role.
11392    '''
11393    __slots__ = [
11394        'meta',
11395        'rate_limit',
11396        'role',
11397    ]
11398
11399    def __init__(
11400        self,
11401        meta=None,
11402        rate_limit=None,
11403        role=None,
11404    ):
11405        self.meta = meta if meta is not None else None
11406        '''
11407         Reserved for future use.
11408        '''
11409        self.rate_limit = rate_limit if rate_limit is not None else None
11410        '''
11411         Rate limit information.
11412        '''
11413        self.role = role if role is not None else None
11414        '''
11415         The requested Role.
11416        '''
11417
11418    def __repr__(self):
11419        return '<sdm.RoleGetResponse ' + \
11420            'meta: ' + repr(self.meta) + ' ' +\
11421            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11422            'role: ' + repr(self.role) + ' ' +\
11423            '>'
11424
11425    def to_dict(self):
11426        return {
11427            'meta': self.meta,
11428            'rate_limit': self.rate_limit,
11429            'role': self.role,
11430        }
11431
11432    @classmethod
11433    def from_dict(cls, d):
11434        return cls(
11435            meta=d.get('meta'),
11436            rate_limit=d.get('rate_limit'),
11437            role=d.get('role'),
11438        )
11439
11440
11441class RoleGrant:
11442    '''
11443     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
11444     
11445     Deprecated: use Role access rules instead.
11446    '''
11447    __slots__ = [
11448        'id',
11449        'resource_id',
11450        'role_id',
11451    ]
11452
11453    def __init__(
11454        self,
11455        id=None,
11456        resource_id=None,
11457        role_id=None,
11458    ):
11459        self.id = id if id is not None else ''
11460        '''
11461         Unique identifier of the RoleGrant.
11462        '''
11463        self.resource_id = resource_id if resource_id is not None else ''
11464        '''
11465         The id of the resource of this RoleGrant.
11466        '''
11467        self.role_id = role_id if role_id is not None else ''
11468        '''
11469         The id of the attached role of this RoleGrant.
11470        '''
11471
11472    def __repr__(self):
11473        return '<sdm.RoleGrant ' + \
11474            'id: ' + repr(self.id) + ' ' +\
11475            'resource_id: ' + repr(self.resource_id) + ' ' +\
11476            'role_id: ' + repr(self.role_id) + ' ' +\
11477            '>'
11478
11479    def to_dict(self):
11480        return {
11481            'id': self.id,
11482            'resource_id': self.resource_id,
11483            'role_id': self.role_id,
11484        }
11485
11486    @classmethod
11487    def from_dict(cls, d):
11488        return cls(
11489            id=d.get('id'),
11490            resource_id=d.get('resource_id'),
11491            role_id=d.get('role_id'),
11492        )
11493
11494
11495class RoleGrantCreateResponse:
11496    '''
11497     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
11498     
11499     Deprecated: use Role access rules instead.
11500    '''
11501    __slots__ = [
11502        'meta',
11503        'rate_limit',
11504        'role_grant',
11505    ]
11506
11507    def __init__(
11508        self,
11509        meta=None,
11510        rate_limit=None,
11511        role_grant=None,
11512    ):
11513        self.meta = meta if meta is not None else None
11514        '''
11515         Reserved for future use.
11516        '''
11517        self.rate_limit = rate_limit if rate_limit is not None else None
11518        '''
11519         Rate limit information.
11520        '''
11521        self.role_grant = role_grant if role_grant is not None else None
11522        '''
11523         The created RoleGrant.
11524        '''
11525
11526    def __repr__(self):
11527        return '<sdm.RoleGrantCreateResponse ' + \
11528            'meta: ' + repr(self.meta) + ' ' +\
11529            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11530            'role_grant: ' + repr(self.role_grant) + ' ' +\
11531            '>'
11532
11533    def to_dict(self):
11534        return {
11535            'meta': self.meta,
11536            'rate_limit': self.rate_limit,
11537            'role_grant': self.role_grant,
11538        }
11539
11540    @classmethod
11541    def from_dict(cls, d):
11542        return cls(
11543            meta=d.get('meta'),
11544            rate_limit=d.get('rate_limit'),
11545            role_grant=d.get('role_grant'),
11546        )
11547
11548
11549class RoleGrantDeleteResponse:
11550    '''
11551     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
11552     
11553     Deprecated: use Role access rules instead.
11554    '''
11555    __slots__ = [
11556        'meta',
11557        'rate_limit',
11558    ]
11559
11560    def __init__(
11561        self,
11562        meta=None,
11563        rate_limit=None,
11564    ):
11565        self.meta = meta if meta is not None else None
11566        '''
11567         Reserved for future use.
11568        '''
11569        self.rate_limit = rate_limit if rate_limit is not None else None
11570        '''
11571         Rate limit information.
11572        '''
11573
11574    def __repr__(self):
11575        return '<sdm.RoleGrantDeleteResponse ' + \
11576            'meta: ' + repr(self.meta) + ' ' +\
11577            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11578            '>'
11579
11580    def to_dict(self):
11581        return {
11582            'meta': self.meta,
11583            'rate_limit': self.rate_limit,
11584        }
11585
11586    @classmethod
11587    def from_dict(cls, d):
11588        return cls(
11589            meta=d.get('meta'),
11590            rate_limit=d.get('rate_limit'),
11591        )
11592
11593
11594class RoleGrantGetResponse:
11595    '''
11596     RoleGrantGetResponse returns a requested RoleGrant.
11597     
11598     Deprecated: use Role access rules instead.
11599    '''
11600    __slots__ = [
11601        'meta',
11602        'rate_limit',
11603        'role_grant',
11604    ]
11605
11606    def __init__(
11607        self,
11608        meta=None,
11609        rate_limit=None,
11610        role_grant=None,
11611    ):
11612        self.meta = meta if meta is not None else None
11613        '''
11614         Reserved for future use.
11615        '''
11616        self.rate_limit = rate_limit if rate_limit is not None else None
11617        '''
11618         Rate limit information.
11619        '''
11620        self.role_grant = role_grant if role_grant is not None else None
11621        '''
11622         The requested RoleGrant.
11623        '''
11624
11625    def __repr__(self):
11626        return '<sdm.RoleGrantGetResponse ' + \
11627            'meta: ' + repr(self.meta) + ' ' +\
11628            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11629            'role_grant: ' + repr(self.role_grant) + ' ' +\
11630            '>'
11631
11632    def to_dict(self):
11633        return {
11634            'meta': self.meta,
11635            'rate_limit': self.rate_limit,
11636            'role_grant': self.role_grant,
11637        }
11638
11639    @classmethod
11640    def from_dict(cls, d):
11641        return cls(
11642            meta=d.get('meta'),
11643            rate_limit=d.get('rate_limit'),
11644            role_grant=d.get('role_grant'),
11645        )
11646
11647
11648class RoleUpdateResponse:
11649    '''
11650     RoleUpdateResponse returns the fields of a Role after it has been updated by
11651     a RoleUpdateRequest.
11652    '''
11653    __slots__ = [
11654        'meta',
11655        'rate_limit',
11656        'role',
11657    ]
11658
11659    def __init__(
11660        self,
11661        meta=None,
11662        rate_limit=None,
11663        role=None,
11664    ):
11665        self.meta = meta if meta is not None else None
11666        '''
11667         Reserved for future use.
11668        '''
11669        self.rate_limit = rate_limit if rate_limit is not None else None
11670        '''
11671         Rate limit information.
11672        '''
11673        self.role = role if role is not None else None
11674        '''
11675         The updated Role.
11676        '''
11677
11678    def __repr__(self):
11679        return '<sdm.RoleUpdateResponse ' + \
11680            'meta: ' + repr(self.meta) + ' ' +\
11681            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11682            'role: ' + repr(self.role) + ' ' +\
11683            '>'
11684
11685    def to_dict(self):
11686        return {
11687            'meta': self.meta,
11688            'rate_limit': self.rate_limit,
11689            'role': self.role,
11690        }
11691
11692    @classmethod
11693    def from_dict(cls, d):
11694        return cls(
11695            meta=d.get('meta'),
11696            rate_limit=d.get('rate_limit'),
11697            role=d.get('role'),
11698        )
11699
11700
11701class SQLServer:
11702    '''
11703
11704    '''
11705    __slots__ = [
11706        'bind_interface',
11707        'database',
11708        'egress_filter',
11709        'healthy',
11710        'hostname',
11711        'id',
11712        'name',
11713        'override_database',
11714        'password',
11715        'port',
11716        'port_override',
11717        'schema',
11718        'secret_store_id',
11719        'tags',
11720        'username',
11721    ]
11722
11723    def __init__(
11724        self,
11725        bind_interface=None,
11726        database=None,
11727        egress_filter=None,
11728        healthy=None,
11729        hostname=None,
11730        id=None,
11731        name=None,
11732        override_database=None,
11733        password=None,
11734        port=None,
11735        port_override=None,
11736        schema=None,
11737        secret_store_id=None,
11738        tags=None,
11739        username=None,
11740    ):
11741        self.bind_interface = bind_interface if bind_interface is not None else ''
11742        '''
11743         Bind interface
11744        '''
11745        self.database = database if database is not None else ''
11746        '''
11747
11748        '''
11749        self.egress_filter = egress_filter if egress_filter is not None else ''
11750        '''
11751         A filter applied to the routing logic to pin datasource to nodes.
11752        '''
11753        self.healthy = healthy if healthy is not None else False
11754        '''
11755         True if the datasource is reachable and the credentials are valid.
11756        '''
11757        self.hostname = hostname if hostname is not None else ''
11758        '''
11759
11760        '''
11761        self.id = id if id is not None else ''
11762        '''
11763         Unique identifier of the Resource.
11764        '''
11765        self.name = name if name is not None else ''
11766        '''
11767         Unique human-readable name of the Resource.
11768        '''
11769        self.override_database = override_database if override_database is not None else False
11770        '''
11771
11772        '''
11773        self.password = password if password is not None else ''
11774        '''
11775
11776        '''
11777        self.port = port if port is not None else 0
11778        '''
11779
11780        '''
11781        self.port_override = port_override if port_override is not None else 0
11782        '''
11783
11784        '''
11785        self.schema = schema if schema is not None else ''
11786        '''
11787
11788        '''
11789        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11790        '''
11791         ID of the secret store containing credentials for this resource, if any.
11792        '''
11793        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11794        '''
11795         Tags is a map of key, value pairs.
11796        '''
11797        self.username = username if username is not None else ''
11798        '''
11799
11800        '''
11801
11802    def __repr__(self):
11803        return '<sdm.SQLServer ' + \
11804            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11805            'database: ' + repr(self.database) + ' ' +\
11806            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11807            'healthy: ' + repr(self.healthy) + ' ' +\
11808            'hostname: ' + repr(self.hostname) + ' ' +\
11809            'id: ' + repr(self.id) + ' ' +\
11810            'name: ' + repr(self.name) + ' ' +\
11811            'override_database: ' + repr(self.override_database) + ' ' +\
11812            'password: ' + repr(self.password) + ' ' +\
11813            'port: ' + repr(self.port) + ' ' +\
11814            'port_override: ' + repr(self.port_override) + ' ' +\
11815            'schema: ' + repr(self.schema) + ' ' +\
11816            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11817            'tags: ' + repr(self.tags) + ' ' +\
11818            'username: ' + repr(self.username) + ' ' +\
11819            '>'
11820
11821    def to_dict(self):
11822        return {
11823            'bind_interface': self.bind_interface,
11824            'database': self.database,
11825            'egress_filter': self.egress_filter,
11826            'healthy': self.healthy,
11827            'hostname': self.hostname,
11828            'id': self.id,
11829            'name': self.name,
11830            'override_database': self.override_database,
11831            'password': self.password,
11832            'port': self.port,
11833            'port_override': self.port_override,
11834            'schema': self.schema,
11835            'secret_store_id': self.secret_store_id,
11836            'tags': self.tags,
11837            'username': self.username,
11838        }
11839
11840    @classmethod
11841    def from_dict(cls, d):
11842        return cls(
11843            bind_interface=d.get('bind_interface'),
11844            database=d.get('database'),
11845            egress_filter=d.get('egress_filter'),
11846            healthy=d.get('healthy'),
11847            hostname=d.get('hostname'),
11848            id=d.get('id'),
11849            name=d.get('name'),
11850            override_database=d.get('override_database'),
11851            password=d.get('password'),
11852            port=d.get('port'),
11853            port_override=d.get('port_override'),
11854            schema=d.get('schema'),
11855            secret_store_id=d.get('secret_store_id'),
11856            tags=d.get('tags'),
11857            username=d.get('username'),
11858        )
11859
11860
11861class SSH:
11862    '''
11863
11864    '''
11865    __slots__ = [
11866        'allow_deprecated_key_exchanges',
11867        'bind_interface',
11868        'egress_filter',
11869        'healthy',
11870        'hostname',
11871        'id',
11872        'key_type',
11873        'name',
11874        'port',
11875        'port_forwarding',
11876        'port_override',
11877        'public_key',
11878        'secret_store_id',
11879        'tags',
11880        'username',
11881    ]
11882
11883    def __init__(
11884        self,
11885        allow_deprecated_key_exchanges=None,
11886        bind_interface=None,
11887        egress_filter=None,
11888        healthy=None,
11889        hostname=None,
11890        id=None,
11891        key_type=None,
11892        name=None,
11893        port=None,
11894        port_forwarding=None,
11895        port_override=None,
11896        public_key=None,
11897        secret_store_id=None,
11898        tags=None,
11899        username=None,
11900    ):
11901        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11902        '''
11903
11904        '''
11905        self.bind_interface = bind_interface if bind_interface is not None else ''
11906        '''
11907         Bind interface
11908        '''
11909        self.egress_filter = egress_filter if egress_filter is not None else ''
11910        '''
11911         A filter applied to the routing logic to pin datasource to nodes.
11912        '''
11913        self.healthy = healthy if healthy is not None else False
11914        '''
11915         True if the datasource is reachable and the credentials are valid.
11916        '''
11917        self.hostname = hostname if hostname is not None else ''
11918        '''
11919
11920        '''
11921        self.id = id if id is not None else ''
11922        '''
11923         Unique identifier of the Resource.
11924        '''
11925        self.key_type = key_type if key_type is not None else ''
11926        '''
11927
11928        '''
11929        self.name = name if name is not None else ''
11930        '''
11931         Unique human-readable name of the Resource.
11932        '''
11933        self.port = port if port is not None else 0
11934        '''
11935
11936        '''
11937        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11938        '''
11939
11940        '''
11941        self.port_override = port_override if port_override is not None else 0
11942        '''
11943
11944        '''
11945        self.public_key = public_key if public_key is not None else ''
11946        '''
11947
11948        '''
11949        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11950        '''
11951         ID of the secret store containing credentials for this resource, if any.
11952        '''
11953        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11954        '''
11955         Tags is a map of key, value pairs.
11956        '''
11957        self.username = username if username is not None else ''
11958        '''
11959
11960        '''
11961
11962    def __repr__(self):
11963        return '<sdm.SSH ' + \
11964            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11965            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11966            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11967            'healthy: ' + repr(self.healthy) + ' ' +\
11968            'hostname: ' + repr(self.hostname) + ' ' +\
11969            'id: ' + repr(self.id) + ' ' +\
11970            'key_type: ' + repr(self.key_type) + ' ' +\
11971            'name: ' + repr(self.name) + ' ' +\
11972            'port: ' + repr(self.port) + ' ' +\
11973            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11974            'port_override: ' + repr(self.port_override) + ' ' +\
11975            'public_key: ' + repr(self.public_key) + ' ' +\
11976            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11977            'tags: ' + repr(self.tags) + ' ' +\
11978            'username: ' + repr(self.username) + ' ' +\
11979            '>'
11980
11981    def to_dict(self):
11982        return {
11983            'allow_deprecated_key_exchanges':
11984            self.allow_deprecated_key_exchanges,
11985            'bind_interface': self.bind_interface,
11986            'egress_filter': self.egress_filter,
11987            'healthy': self.healthy,
11988            'hostname': self.hostname,
11989            'id': self.id,
11990            'key_type': self.key_type,
11991            'name': self.name,
11992            'port': self.port,
11993            'port_forwarding': self.port_forwarding,
11994            'port_override': self.port_override,
11995            'public_key': self.public_key,
11996            'secret_store_id': self.secret_store_id,
11997            'tags': self.tags,
11998            'username': self.username,
11999        }
12000
12001    @classmethod
12002    def from_dict(cls, d):
12003        return cls(
12004            allow_deprecated_key_exchanges=d.get(
12005                'allow_deprecated_key_exchanges'),
12006            bind_interface=d.get('bind_interface'),
12007            egress_filter=d.get('egress_filter'),
12008            healthy=d.get('healthy'),
12009            hostname=d.get('hostname'),
12010            id=d.get('id'),
12011            key_type=d.get('key_type'),
12012            name=d.get('name'),
12013            port=d.get('port'),
12014            port_forwarding=d.get('port_forwarding'),
12015            port_override=d.get('port_override'),
12016            public_key=d.get('public_key'),
12017            secret_store_id=d.get('secret_store_id'),
12018            tags=d.get('tags'),
12019            username=d.get('username'),
12020        )
12021
12022
12023class SSHCert:
12024    '''
12025
12026    '''
12027    __slots__ = [
12028        'allow_deprecated_key_exchanges',
12029        'bind_interface',
12030        'egress_filter',
12031        'healthy',
12032        'hostname',
12033        'id',
12034        'key_type',
12035        'name',
12036        'port',
12037        'port_forwarding',
12038        'port_override',
12039        'remote_identity_group_id',
12040        'remote_identity_healthcheck_username',
12041        'secret_store_id',
12042        'tags',
12043        'username',
12044    ]
12045
12046    def __init__(
12047        self,
12048        allow_deprecated_key_exchanges=None,
12049        bind_interface=None,
12050        egress_filter=None,
12051        healthy=None,
12052        hostname=None,
12053        id=None,
12054        key_type=None,
12055        name=None,
12056        port=None,
12057        port_forwarding=None,
12058        port_override=None,
12059        remote_identity_group_id=None,
12060        remote_identity_healthcheck_username=None,
12061        secret_store_id=None,
12062        tags=None,
12063        username=None,
12064    ):
12065        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12066        '''
12067
12068        '''
12069        self.bind_interface = bind_interface if bind_interface is not None else ''
12070        '''
12071         Bind interface
12072        '''
12073        self.egress_filter = egress_filter if egress_filter is not None else ''
12074        '''
12075         A filter applied to the routing logic to pin datasource to nodes.
12076        '''
12077        self.healthy = healthy if healthy is not None else False
12078        '''
12079         True if the datasource is reachable and the credentials are valid.
12080        '''
12081        self.hostname = hostname if hostname is not None else ''
12082        '''
12083
12084        '''
12085        self.id = id if id is not None else ''
12086        '''
12087         Unique identifier of the Resource.
12088        '''
12089        self.key_type = key_type if key_type is not None else ''
12090        '''
12091
12092        '''
12093        self.name = name if name is not None else ''
12094        '''
12095         Unique human-readable name of the Resource.
12096        '''
12097        self.port = port if port is not None else 0
12098        '''
12099
12100        '''
12101        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12102        '''
12103
12104        '''
12105        self.port_override = port_override if port_override is not None else 0
12106        '''
12107
12108        '''
12109        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12110        '''
12111
12112        '''
12113        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12114        '''
12115
12116        '''
12117        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12118        '''
12119         ID of the secret store containing credentials for this resource, if any.
12120        '''
12121        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12122        '''
12123         Tags is a map of key, value pairs.
12124        '''
12125        self.username = username if username is not None else ''
12126        '''
12127
12128        '''
12129
12130    def __repr__(self):
12131        return '<sdm.SSHCert ' + \
12132            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12135            'healthy: ' + repr(self.healthy) + ' ' +\
12136            'hostname: ' + repr(self.hostname) + ' ' +\
12137            'id: ' + repr(self.id) + ' ' +\
12138            'key_type: ' + repr(self.key_type) + ' ' +\
12139            'name: ' + repr(self.name) + ' ' +\
12140            'port: ' + repr(self.port) + ' ' +\
12141            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12142            'port_override: ' + repr(self.port_override) + ' ' +\
12143            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
12144            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
12145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12146            'tags: ' + repr(self.tags) + ' ' +\
12147            'username: ' + repr(self.username) + ' ' +\
12148            '>'
12149
12150    def to_dict(self):
12151        return {
12152            'allow_deprecated_key_exchanges':
12153            self.allow_deprecated_key_exchanges,
12154            'bind_interface': self.bind_interface,
12155            'egress_filter': self.egress_filter,
12156            'healthy': self.healthy,
12157            'hostname': self.hostname,
12158            'id': self.id,
12159            'key_type': self.key_type,
12160            'name': self.name,
12161            'port': self.port,
12162            'port_forwarding': self.port_forwarding,
12163            'port_override': self.port_override,
12164            'remote_identity_group_id': self.remote_identity_group_id,
12165            'remote_identity_healthcheck_username':
12166            self.remote_identity_healthcheck_username,
12167            'secret_store_id': self.secret_store_id,
12168            'tags': self.tags,
12169            'username': self.username,
12170        }
12171
12172    @classmethod
12173    def from_dict(cls, d):
12174        return cls(
12175            allow_deprecated_key_exchanges=d.get(
12176                'allow_deprecated_key_exchanges'),
12177            bind_interface=d.get('bind_interface'),
12178            egress_filter=d.get('egress_filter'),
12179            healthy=d.get('healthy'),
12180            hostname=d.get('hostname'),
12181            id=d.get('id'),
12182            key_type=d.get('key_type'),
12183            name=d.get('name'),
12184            port=d.get('port'),
12185            port_forwarding=d.get('port_forwarding'),
12186            port_override=d.get('port_override'),
12187            remote_identity_group_id=d.get('remote_identity_group_id'),
12188            remote_identity_healthcheck_username=d.get(
12189                'remote_identity_healthcheck_username'),
12190            secret_store_id=d.get('secret_store_id'),
12191            tags=d.get('tags'),
12192            username=d.get('username'),
12193        )
12194
12195
12196class SSHCustomerKey:
12197    '''
12198
12199    '''
12200    __slots__ = [
12201        'allow_deprecated_key_exchanges',
12202        'bind_interface',
12203        'egress_filter',
12204        'healthy',
12205        'hostname',
12206        'id',
12207        'name',
12208        'port',
12209        'port_forwarding',
12210        'port_override',
12211        'private_key',
12212        'secret_store_id',
12213        'tags',
12214        'username',
12215    ]
12216
12217    def __init__(
12218        self,
12219        allow_deprecated_key_exchanges=None,
12220        bind_interface=None,
12221        egress_filter=None,
12222        healthy=None,
12223        hostname=None,
12224        id=None,
12225        name=None,
12226        port=None,
12227        port_forwarding=None,
12228        port_override=None,
12229        private_key=None,
12230        secret_store_id=None,
12231        tags=None,
12232        username=None,
12233    ):
12234        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12235        '''
12236
12237        '''
12238        self.bind_interface = bind_interface if bind_interface is not None else ''
12239        '''
12240         Bind interface
12241        '''
12242        self.egress_filter = egress_filter if egress_filter is not None else ''
12243        '''
12244         A filter applied to the routing logic to pin datasource to nodes.
12245        '''
12246        self.healthy = healthy if healthy is not None else False
12247        '''
12248         True if the datasource is reachable and the credentials are valid.
12249        '''
12250        self.hostname = hostname if hostname is not None else ''
12251        '''
12252
12253        '''
12254        self.id = id if id is not None else ''
12255        '''
12256         Unique identifier of the Resource.
12257        '''
12258        self.name = name if name is not None else ''
12259        '''
12260         Unique human-readable name of the Resource.
12261        '''
12262        self.port = port if port is not None else 0
12263        '''
12264
12265        '''
12266        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12267        '''
12268
12269        '''
12270        self.port_override = port_override if port_override is not None else 0
12271        '''
12272
12273        '''
12274        self.private_key = private_key if private_key is not None else ''
12275        '''
12276
12277        '''
12278        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12279        '''
12280         ID of the secret store containing credentials for this resource, if any.
12281        '''
12282        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12283        '''
12284         Tags is a map of key, value pairs.
12285        '''
12286        self.username = username if username is not None else ''
12287        '''
12288
12289        '''
12290
12291    def __repr__(self):
12292        return '<sdm.SSHCustomerKey ' + \
12293            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12294            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12295            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12296            'healthy: ' + repr(self.healthy) + ' ' +\
12297            'hostname: ' + repr(self.hostname) + ' ' +\
12298            'id: ' + repr(self.id) + ' ' +\
12299            'name: ' + repr(self.name) + ' ' +\
12300            'port: ' + repr(self.port) + ' ' +\
12301            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12302            'port_override: ' + repr(self.port_override) + ' ' +\
12303            'private_key: ' + repr(self.private_key) + ' ' +\
12304            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12305            'tags: ' + repr(self.tags) + ' ' +\
12306            'username: ' + repr(self.username) + ' ' +\
12307            '>'
12308
12309    def to_dict(self):
12310        return {
12311            'allow_deprecated_key_exchanges':
12312            self.allow_deprecated_key_exchanges,
12313            'bind_interface': self.bind_interface,
12314            'egress_filter': self.egress_filter,
12315            'healthy': self.healthy,
12316            'hostname': self.hostname,
12317            'id': self.id,
12318            'name': self.name,
12319            'port': self.port,
12320            'port_forwarding': self.port_forwarding,
12321            'port_override': self.port_override,
12322            'private_key': self.private_key,
12323            'secret_store_id': self.secret_store_id,
12324            'tags': self.tags,
12325            'username': self.username,
12326        }
12327
12328    @classmethod
12329    def from_dict(cls, d):
12330        return cls(
12331            allow_deprecated_key_exchanges=d.get(
12332                'allow_deprecated_key_exchanges'),
12333            bind_interface=d.get('bind_interface'),
12334            egress_filter=d.get('egress_filter'),
12335            healthy=d.get('healthy'),
12336            hostname=d.get('hostname'),
12337            id=d.get('id'),
12338            name=d.get('name'),
12339            port=d.get('port'),
12340            port_forwarding=d.get('port_forwarding'),
12341            port_override=d.get('port_override'),
12342            private_key=d.get('private_key'),
12343            secret_store_id=d.get('secret_store_id'),
12344            tags=d.get('tags'),
12345            username=d.get('username'),
12346        )
12347
12348
12349class SecretStoreCreateResponse:
12350    '''
12351     SecretStoreCreateResponse reports how the SecretStores were created in the system.
12352    '''
12353    __slots__ = [
12354        'meta',
12355        'rate_limit',
12356        'secret_store',
12357    ]
12358
12359    def __init__(
12360        self,
12361        meta=None,
12362        rate_limit=None,
12363        secret_store=None,
12364    ):
12365        self.meta = meta if meta is not None else None
12366        '''
12367         Reserved for future use.
12368        '''
12369        self.rate_limit = rate_limit if rate_limit is not None else None
12370        '''
12371         Rate limit information.
12372        '''
12373        self.secret_store = secret_store if secret_store is not None else None
12374        '''
12375         The created SecretStore.
12376        '''
12377
12378    def __repr__(self):
12379        return '<sdm.SecretStoreCreateResponse ' + \
12380            'meta: ' + repr(self.meta) + ' ' +\
12381            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12382            'secret_store: ' + repr(self.secret_store) + ' ' +\
12383            '>'
12384
12385    def to_dict(self):
12386        return {
12387            'meta': self.meta,
12388            'rate_limit': self.rate_limit,
12389            'secret_store': self.secret_store,
12390        }
12391
12392    @classmethod
12393    def from_dict(cls, d):
12394        return cls(
12395            meta=d.get('meta'),
12396            rate_limit=d.get('rate_limit'),
12397            secret_store=d.get('secret_store'),
12398        )
12399
12400
12401class SecretStoreDeleteResponse:
12402    '''
12403     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
12404    '''
12405    __slots__ = [
12406        'meta',
12407        'rate_limit',
12408    ]
12409
12410    def __init__(
12411        self,
12412        meta=None,
12413        rate_limit=None,
12414    ):
12415        self.meta = meta if meta is not None else None
12416        '''
12417         Reserved for future use.
12418        '''
12419        self.rate_limit = rate_limit if rate_limit is not None else None
12420        '''
12421         Rate limit information.
12422        '''
12423
12424    def __repr__(self):
12425        return '<sdm.SecretStoreDeleteResponse ' + \
12426            'meta: ' + repr(self.meta) + ' ' +\
12427            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12428            '>'
12429
12430    def to_dict(self):
12431        return {
12432            'meta': self.meta,
12433            'rate_limit': self.rate_limit,
12434        }
12435
12436    @classmethod
12437    def from_dict(cls, d):
12438        return cls(
12439            meta=d.get('meta'),
12440            rate_limit=d.get('rate_limit'),
12441        )
12442
12443
12444class SecretStoreGetResponse:
12445    '''
12446     SecretStoreGetResponse returns a requested SecretStore.
12447    '''
12448    __slots__ = [
12449        'meta',
12450        'rate_limit',
12451        'secret_store',
12452    ]
12453
12454    def __init__(
12455        self,
12456        meta=None,
12457        rate_limit=None,
12458        secret_store=None,
12459    ):
12460        self.meta = meta if meta is not None else None
12461        '''
12462         Reserved for future use.
12463        '''
12464        self.rate_limit = rate_limit if rate_limit is not None else None
12465        '''
12466         Rate limit information.
12467        '''
12468        self.secret_store = secret_store if secret_store is not None else None
12469        '''
12470         The requested SecretStore.
12471        '''
12472
12473    def __repr__(self):
12474        return '<sdm.SecretStoreGetResponse ' + \
12475            'meta: ' + repr(self.meta) + ' ' +\
12476            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12477            'secret_store: ' + repr(self.secret_store) + ' ' +\
12478            '>'
12479
12480    def to_dict(self):
12481        return {
12482            'meta': self.meta,
12483            'rate_limit': self.rate_limit,
12484            'secret_store': self.secret_store,
12485        }
12486
12487    @classmethod
12488    def from_dict(cls, d):
12489        return cls(
12490            meta=d.get('meta'),
12491            rate_limit=d.get('rate_limit'),
12492            secret_store=d.get('secret_store'),
12493        )
12494
12495
12496class SecretStoreUpdateResponse:
12497    '''
12498     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12499     a SecretStoreUpdateRequest.
12500    '''
12501    __slots__ = [
12502        'meta',
12503        'rate_limit',
12504        'secret_store',
12505    ]
12506
12507    def __init__(
12508        self,
12509        meta=None,
12510        rate_limit=None,
12511        secret_store=None,
12512    ):
12513        self.meta = meta if meta is not None else None
12514        '''
12515         Reserved for future use.
12516        '''
12517        self.rate_limit = rate_limit if rate_limit is not None else None
12518        '''
12519         Rate limit information.
12520        '''
12521        self.secret_store = secret_store if secret_store is not None else None
12522        '''
12523         The updated SecretStore.
12524        '''
12525
12526    def __repr__(self):
12527        return '<sdm.SecretStoreUpdateResponse ' + \
12528            'meta: ' + repr(self.meta) + ' ' +\
12529            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12530            'secret_store: ' + repr(self.secret_store) + ' ' +\
12531            '>'
12532
12533    def to_dict(self):
12534        return {
12535            'meta': self.meta,
12536            'rate_limit': self.rate_limit,
12537            'secret_store': self.secret_store,
12538        }
12539
12540    @classmethod
12541    def from_dict(cls, d):
12542        return cls(
12543            meta=d.get('meta'),
12544            rate_limit=d.get('rate_limit'),
12545            secret_store=d.get('secret_store'),
12546        )
12547
12548
12549class Service:
12550    '''
12551     A Service is a service account that can connect to resources they are granted
12552     directly, or granted via roles. Services are typically automated jobs.
12553    '''
12554    __slots__ = [
12555        'id',
12556        'name',
12557        'suspended',
12558        'tags',
12559    ]
12560
12561    def __init__(
12562        self,
12563        id=None,
12564        name=None,
12565        suspended=None,
12566        tags=None,
12567    ):
12568        self.id = id if id is not None else ''
12569        '''
12570         Unique identifier of the Service.
12571        '''
12572        self.name = name if name is not None else ''
12573        '''
12574         Unique human-readable name of the Service.
12575        '''
12576        self.suspended = suspended if suspended is not None else False
12577        '''
12578         The Service's suspended state.
12579        '''
12580        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12581        '''
12582         Tags is a map of key, value pairs.
12583        '''
12584
12585    def __repr__(self):
12586        return '<sdm.Service ' + \
12587            'id: ' + repr(self.id) + ' ' +\
12588            'name: ' + repr(self.name) + ' ' +\
12589            'suspended: ' + repr(self.suspended) + ' ' +\
12590            'tags: ' + repr(self.tags) + ' ' +\
12591            '>'
12592
12593    def to_dict(self):
12594        return {
12595            'id': self.id,
12596            'name': self.name,
12597            'suspended': self.suspended,
12598            'tags': self.tags,
12599        }
12600
12601    @classmethod
12602    def from_dict(cls, d):
12603        return cls(
12604            id=d.get('id'),
12605            name=d.get('name'),
12606            suspended=d.get('suspended'),
12607            tags=d.get('tags'),
12608        )
12609
12610
12611class SingleStore:
12612    '''
12613
12614    '''
12615    __slots__ = [
12616        'bind_interface',
12617        'database',
12618        'egress_filter',
12619        'healthy',
12620        'hostname',
12621        'id',
12622        'name',
12623        'password',
12624        'port',
12625        'port_override',
12626        'secret_store_id',
12627        'tags',
12628        'username',
12629    ]
12630
12631    def __init__(
12632        self,
12633        bind_interface=None,
12634        database=None,
12635        egress_filter=None,
12636        healthy=None,
12637        hostname=None,
12638        id=None,
12639        name=None,
12640        password=None,
12641        port=None,
12642        port_override=None,
12643        secret_store_id=None,
12644        tags=None,
12645        username=None,
12646    ):
12647        self.bind_interface = bind_interface if bind_interface is not None else ''
12648        '''
12649         Bind interface
12650        '''
12651        self.database = database if database is not None else ''
12652        '''
12653
12654        '''
12655        self.egress_filter = egress_filter if egress_filter is not None else ''
12656        '''
12657         A filter applied to the routing logic to pin datasource to nodes.
12658        '''
12659        self.healthy = healthy if healthy is not None else False
12660        '''
12661         True if the datasource is reachable and the credentials are valid.
12662        '''
12663        self.hostname = hostname if hostname is not None else ''
12664        '''
12665
12666        '''
12667        self.id = id if id is not None else ''
12668        '''
12669         Unique identifier of the Resource.
12670        '''
12671        self.name = name if name is not None else ''
12672        '''
12673         Unique human-readable name of the Resource.
12674        '''
12675        self.password = password if password is not None else ''
12676        '''
12677
12678        '''
12679        self.port = port if port is not None else 0
12680        '''
12681
12682        '''
12683        self.port_override = port_override if port_override is not None else 0
12684        '''
12685
12686        '''
12687        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12688        '''
12689         ID of the secret store containing credentials for this resource, if any.
12690        '''
12691        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12692        '''
12693         Tags is a map of key, value pairs.
12694        '''
12695        self.username = username if username is not None else ''
12696        '''
12697
12698        '''
12699
12700    def __repr__(self):
12701        return '<sdm.SingleStore ' + \
12702            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12703            'database: ' + repr(self.database) + ' ' +\
12704            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12705            'healthy: ' + repr(self.healthy) + ' ' +\
12706            'hostname: ' + repr(self.hostname) + ' ' +\
12707            'id: ' + repr(self.id) + ' ' +\
12708            'name: ' + repr(self.name) + ' ' +\
12709            'password: ' + repr(self.password) + ' ' +\
12710            'port: ' + repr(self.port) + ' ' +\
12711            'port_override: ' + repr(self.port_override) + ' ' +\
12712            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12713            'tags: ' + repr(self.tags) + ' ' +\
12714            'username: ' + repr(self.username) + ' ' +\
12715            '>'
12716
12717    def to_dict(self):
12718        return {
12719            'bind_interface': self.bind_interface,
12720            'database': self.database,
12721            'egress_filter': self.egress_filter,
12722            'healthy': self.healthy,
12723            'hostname': self.hostname,
12724            'id': self.id,
12725            'name': self.name,
12726            'password': self.password,
12727            'port': self.port,
12728            'port_override': self.port_override,
12729            'secret_store_id': self.secret_store_id,
12730            'tags': self.tags,
12731            'username': self.username,
12732        }
12733
12734    @classmethod
12735    def from_dict(cls, d):
12736        return cls(
12737            bind_interface=d.get('bind_interface'),
12738            database=d.get('database'),
12739            egress_filter=d.get('egress_filter'),
12740            healthy=d.get('healthy'),
12741            hostname=d.get('hostname'),
12742            id=d.get('id'),
12743            name=d.get('name'),
12744            password=d.get('password'),
12745            port=d.get('port'),
12746            port_override=d.get('port_override'),
12747            secret_store_id=d.get('secret_store_id'),
12748            tags=d.get('tags'),
12749            username=d.get('username'),
12750        )
12751
12752
12753class Snowflake:
12754    '''
12755
12756    '''
12757    __slots__ = [
12758        'bind_interface',
12759        'database',
12760        'egress_filter',
12761        'healthy',
12762        'hostname',
12763        'id',
12764        'name',
12765        'password',
12766        'port_override',
12767        'schema',
12768        'secret_store_id',
12769        'tags',
12770        'username',
12771    ]
12772
12773    def __init__(
12774        self,
12775        bind_interface=None,
12776        database=None,
12777        egress_filter=None,
12778        healthy=None,
12779        hostname=None,
12780        id=None,
12781        name=None,
12782        password=None,
12783        port_override=None,
12784        schema=None,
12785        secret_store_id=None,
12786        tags=None,
12787        username=None,
12788    ):
12789        self.bind_interface = bind_interface if bind_interface is not None else ''
12790        '''
12791         Bind interface
12792        '''
12793        self.database = database if database is not None else ''
12794        '''
12795
12796        '''
12797        self.egress_filter = egress_filter if egress_filter is not None else ''
12798        '''
12799         A filter applied to the routing logic to pin datasource to nodes.
12800        '''
12801        self.healthy = healthy if healthy is not None else False
12802        '''
12803         True if the datasource is reachable and the credentials are valid.
12804        '''
12805        self.hostname = hostname if hostname is not None else ''
12806        '''
12807
12808        '''
12809        self.id = id if id is not None else ''
12810        '''
12811         Unique identifier of the Resource.
12812        '''
12813        self.name = name if name is not None else ''
12814        '''
12815         Unique human-readable name of the Resource.
12816        '''
12817        self.password = password if password is not None else ''
12818        '''
12819
12820        '''
12821        self.port_override = port_override if port_override is not None else 0
12822        '''
12823
12824        '''
12825        self.schema = schema if schema is not None else ''
12826        '''
12827
12828        '''
12829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12830        '''
12831         ID of the secret store containing credentials for this resource, if any.
12832        '''
12833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12834        '''
12835         Tags is a map of key, value pairs.
12836        '''
12837        self.username = username if username is not None else ''
12838        '''
12839
12840        '''
12841
12842    def __repr__(self):
12843        return '<sdm.Snowflake ' + \
12844            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12845            'database: ' + repr(self.database) + ' ' +\
12846            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12847            'healthy: ' + repr(self.healthy) + ' ' +\
12848            'hostname: ' + repr(self.hostname) + ' ' +\
12849            'id: ' + repr(self.id) + ' ' +\
12850            'name: ' + repr(self.name) + ' ' +\
12851            'password: ' + repr(self.password) + ' ' +\
12852            'port_override: ' + repr(self.port_override) + ' ' +\
12853            'schema: ' + repr(self.schema) + ' ' +\
12854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12855            'tags: ' + repr(self.tags) + ' ' +\
12856            'username: ' + repr(self.username) + ' ' +\
12857            '>'
12858
12859    def to_dict(self):
12860        return {
12861            'bind_interface': self.bind_interface,
12862            'database': self.database,
12863            'egress_filter': self.egress_filter,
12864            'healthy': self.healthy,
12865            'hostname': self.hostname,
12866            'id': self.id,
12867            'name': self.name,
12868            'password': self.password,
12869            'port_override': self.port_override,
12870            'schema': self.schema,
12871            'secret_store_id': self.secret_store_id,
12872            'tags': self.tags,
12873            'username': self.username,
12874        }
12875
12876    @classmethod
12877    def from_dict(cls, d):
12878        return cls(
12879            bind_interface=d.get('bind_interface'),
12880            database=d.get('database'),
12881            egress_filter=d.get('egress_filter'),
12882            healthy=d.get('healthy'),
12883            hostname=d.get('hostname'),
12884            id=d.get('id'),
12885            name=d.get('name'),
12886            password=d.get('password'),
12887            port_override=d.get('port_override'),
12888            schema=d.get('schema'),
12889            secret_store_id=d.get('secret_store_id'),
12890            tags=d.get('tags'),
12891            username=d.get('username'),
12892        )
12893
12894
12895class Sybase:
12896    '''
12897
12898    '''
12899    __slots__ = [
12900        'bind_interface',
12901        'egress_filter',
12902        'healthy',
12903        'hostname',
12904        'id',
12905        'name',
12906        'password',
12907        'port',
12908        'port_override',
12909        'secret_store_id',
12910        'tags',
12911        'username',
12912    ]
12913
12914    def __init__(
12915        self,
12916        bind_interface=None,
12917        egress_filter=None,
12918        healthy=None,
12919        hostname=None,
12920        id=None,
12921        name=None,
12922        password=None,
12923        port=None,
12924        port_override=None,
12925        secret_store_id=None,
12926        tags=None,
12927        username=None,
12928    ):
12929        self.bind_interface = bind_interface if bind_interface is not None else ''
12930        '''
12931         Bind interface
12932        '''
12933        self.egress_filter = egress_filter if egress_filter is not None else ''
12934        '''
12935         A filter applied to the routing logic to pin datasource to nodes.
12936        '''
12937        self.healthy = healthy if healthy is not None else False
12938        '''
12939         True if the datasource is reachable and the credentials are valid.
12940        '''
12941        self.hostname = hostname if hostname is not None else ''
12942        '''
12943
12944        '''
12945        self.id = id if id is not None else ''
12946        '''
12947         Unique identifier of the Resource.
12948        '''
12949        self.name = name if name is not None else ''
12950        '''
12951         Unique human-readable name of the Resource.
12952        '''
12953        self.password = password if password is not None else ''
12954        '''
12955
12956        '''
12957        self.port = port if port is not None else 0
12958        '''
12959
12960        '''
12961        self.port_override = port_override if port_override is not None else 0
12962        '''
12963
12964        '''
12965        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12966        '''
12967         ID of the secret store containing credentials for this resource, if any.
12968        '''
12969        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12970        '''
12971         Tags is a map of key, value pairs.
12972        '''
12973        self.username = username if username is not None else ''
12974        '''
12975
12976        '''
12977
12978    def __repr__(self):
12979        return '<sdm.Sybase ' + \
12980            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12981            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12982            'healthy: ' + repr(self.healthy) + ' ' +\
12983            'hostname: ' + repr(self.hostname) + ' ' +\
12984            'id: ' + repr(self.id) + ' ' +\
12985            'name: ' + repr(self.name) + ' ' +\
12986            'password: ' + repr(self.password) + ' ' +\
12987            'port: ' + repr(self.port) + ' ' +\
12988            'port_override: ' + repr(self.port_override) + ' ' +\
12989            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12990            'tags: ' + repr(self.tags) + ' ' +\
12991            'username: ' + repr(self.username) + ' ' +\
12992            '>'
12993
12994    def to_dict(self):
12995        return {
12996            'bind_interface': self.bind_interface,
12997            'egress_filter': self.egress_filter,
12998            'healthy': self.healthy,
12999            'hostname': self.hostname,
13000            'id': self.id,
13001            'name': self.name,
13002            'password': self.password,
13003            'port': self.port,
13004            'port_override': self.port_override,
13005            'secret_store_id': self.secret_store_id,
13006            'tags': self.tags,
13007            'username': self.username,
13008        }
13009
13010    @classmethod
13011    def from_dict(cls, d):
13012        return cls(
13013            bind_interface=d.get('bind_interface'),
13014            egress_filter=d.get('egress_filter'),
13015            healthy=d.get('healthy'),
13016            hostname=d.get('hostname'),
13017            id=d.get('id'),
13018            name=d.get('name'),
13019            password=d.get('password'),
13020            port=d.get('port'),
13021            port_override=d.get('port_override'),
13022            secret_store_id=d.get('secret_store_id'),
13023            tags=d.get('tags'),
13024            username=d.get('username'),
13025        )
13026
13027
13028class SybaseIQ:
13029    '''
13030
13031    '''
13032    __slots__ = [
13033        'bind_interface',
13034        'egress_filter',
13035        'healthy',
13036        'hostname',
13037        'id',
13038        'name',
13039        'password',
13040        'port',
13041        'port_override',
13042        'secret_store_id',
13043        'tags',
13044        'username',
13045    ]
13046
13047    def __init__(
13048        self,
13049        bind_interface=None,
13050        egress_filter=None,
13051        healthy=None,
13052        hostname=None,
13053        id=None,
13054        name=None,
13055        password=None,
13056        port=None,
13057        port_override=None,
13058        secret_store_id=None,
13059        tags=None,
13060        username=None,
13061    ):
13062        self.bind_interface = bind_interface if bind_interface is not None else ''
13063        '''
13064         Bind interface
13065        '''
13066        self.egress_filter = egress_filter if egress_filter is not None else ''
13067        '''
13068         A filter applied to the routing logic to pin datasource to nodes.
13069        '''
13070        self.healthy = healthy if healthy is not None else False
13071        '''
13072         True if the datasource is reachable and the credentials are valid.
13073        '''
13074        self.hostname = hostname if hostname is not None else ''
13075        '''
13076
13077        '''
13078        self.id = id if id is not None else ''
13079        '''
13080         Unique identifier of the Resource.
13081        '''
13082        self.name = name if name is not None else ''
13083        '''
13084         Unique human-readable name of the Resource.
13085        '''
13086        self.password = password if password is not None else ''
13087        '''
13088
13089        '''
13090        self.port = port if port is not None else 0
13091        '''
13092
13093        '''
13094        self.port_override = port_override if port_override is not None else 0
13095        '''
13096
13097        '''
13098        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13099        '''
13100         ID of the secret store containing credentials for this resource, if any.
13101        '''
13102        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13103        '''
13104         Tags is a map of key, value pairs.
13105        '''
13106        self.username = username if username is not None else ''
13107        '''
13108
13109        '''
13110
13111    def __repr__(self):
13112        return '<sdm.SybaseIQ ' + \
13113            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13114            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13115            'healthy: ' + repr(self.healthy) + ' ' +\
13116            'hostname: ' + repr(self.hostname) + ' ' +\
13117            'id: ' + repr(self.id) + ' ' +\
13118            'name: ' + repr(self.name) + ' ' +\
13119            'password: ' + repr(self.password) + ' ' +\
13120            'port: ' + repr(self.port) + ' ' +\
13121            'port_override: ' + repr(self.port_override) + ' ' +\
13122            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13123            'tags: ' + repr(self.tags) + ' ' +\
13124            'username: ' + repr(self.username) + ' ' +\
13125            '>'
13126
13127    def to_dict(self):
13128        return {
13129            'bind_interface': self.bind_interface,
13130            'egress_filter': self.egress_filter,
13131            'healthy': self.healthy,
13132            'hostname': self.hostname,
13133            'id': self.id,
13134            'name': self.name,
13135            'password': self.password,
13136            'port': self.port,
13137            'port_override': self.port_override,
13138            'secret_store_id': self.secret_store_id,
13139            'tags': self.tags,
13140            'username': self.username,
13141        }
13142
13143    @classmethod
13144    def from_dict(cls, d):
13145        return cls(
13146            bind_interface=d.get('bind_interface'),
13147            egress_filter=d.get('egress_filter'),
13148            healthy=d.get('healthy'),
13149            hostname=d.get('hostname'),
13150            id=d.get('id'),
13151            name=d.get('name'),
13152            password=d.get('password'),
13153            port=d.get('port'),
13154            port_override=d.get('port_override'),
13155            secret_store_id=d.get('secret_store_id'),
13156            tags=d.get('tags'),
13157            username=d.get('username'),
13158        )
13159
13160
13161class Tag:
13162    '''
13163
13164    '''
13165    __slots__ = [
13166        'name',
13167        'value',
13168    ]
13169
13170    def __init__(
13171        self,
13172        name=None,
13173        value=None,
13174    ):
13175        self.name = name if name is not None else ''
13176        '''
13177
13178        '''
13179        self.value = value if value is not None else ''
13180        '''
13181
13182        '''
13183
13184    def __repr__(self):
13185        return '<sdm.Tag ' + \
13186            'name: ' + repr(self.name) + ' ' +\
13187            'value: ' + repr(self.value) + ' ' +\
13188            '>'
13189
13190    def to_dict(self):
13191        return {
13192            'name': self.name,
13193            'value': self.value,
13194        }
13195
13196    @classmethod
13197    def from_dict(cls, d):
13198        return cls(
13199            name=d.get('name'),
13200            value=d.get('value'),
13201        )
13202
13203
13204class Teradata:
13205    '''
13206
13207    '''
13208    __slots__ = [
13209        'bind_interface',
13210        'egress_filter',
13211        'healthy',
13212        'hostname',
13213        'id',
13214        'name',
13215        'password',
13216        'port',
13217        'port_override',
13218        'secret_store_id',
13219        'tags',
13220        'username',
13221    ]
13222
13223    def __init__(
13224        self,
13225        bind_interface=None,
13226        egress_filter=None,
13227        healthy=None,
13228        hostname=None,
13229        id=None,
13230        name=None,
13231        password=None,
13232        port=None,
13233        port_override=None,
13234        secret_store_id=None,
13235        tags=None,
13236        username=None,
13237    ):
13238        self.bind_interface = bind_interface if bind_interface is not None else ''
13239        '''
13240         Bind interface
13241        '''
13242        self.egress_filter = egress_filter if egress_filter is not None else ''
13243        '''
13244         A filter applied to the routing logic to pin datasource to nodes.
13245        '''
13246        self.healthy = healthy if healthy is not None else False
13247        '''
13248         True if the datasource is reachable and the credentials are valid.
13249        '''
13250        self.hostname = hostname if hostname is not None else ''
13251        '''
13252
13253        '''
13254        self.id = id if id is not None else ''
13255        '''
13256         Unique identifier of the Resource.
13257        '''
13258        self.name = name if name is not None else ''
13259        '''
13260         Unique human-readable name of the Resource.
13261        '''
13262        self.password = password if password is not None else ''
13263        '''
13264
13265        '''
13266        self.port = port if port is not None else 0
13267        '''
13268
13269        '''
13270        self.port_override = port_override if port_override is not None else 0
13271        '''
13272
13273        '''
13274        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13275        '''
13276         ID of the secret store containing credentials for this resource, if any.
13277        '''
13278        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13279        '''
13280         Tags is a map of key, value pairs.
13281        '''
13282        self.username = username if username is not None else ''
13283        '''
13284
13285        '''
13286
13287    def __repr__(self):
13288        return '<sdm.Teradata ' + \
13289            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13290            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13291            'healthy: ' + repr(self.healthy) + ' ' +\
13292            'hostname: ' + repr(self.hostname) + ' ' +\
13293            'id: ' + repr(self.id) + ' ' +\
13294            'name: ' + repr(self.name) + ' ' +\
13295            'password: ' + repr(self.password) + ' ' +\
13296            'port: ' + repr(self.port) + ' ' +\
13297            'port_override: ' + repr(self.port_override) + ' ' +\
13298            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13299            'tags: ' + repr(self.tags) + ' ' +\
13300            'username: ' + repr(self.username) + ' ' +\
13301            '>'
13302
13303    def to_dict(self):
13304        return {
13305            'bind_interface': self.bind_interface,
13306            'egress_filter': self.egress_filter,
13307            'healthy': self.healthy,
13308            'hostname': self.hostname,
13309            'id': self.id,
13310            'name': self.name,
13311            'password': self.password,
13312            'port': self.port,
13313            'port_override': self.port_override,
13314            'secret_store_id': self.secret_store_id,
13315            'tags': self.tags,
13316            'username': self.username,
13317        }
13318
13319    @classmethod
13320    def from_dict(cls, d):
13321        return cls(
13322            bind_interface=d.get('bind_interface'),
13323            egress_filter=d.get('egress_filter'),
13324            healthy=d.get('healthy'),
13325            hostname=d.get('hostname'),
13326            id=d.get('id'),
13327            name=d.get('name'),
13328            password=d.get('password'),
13329            port=d.get('port'),
13330            port_override=d.get('port_override'),
13331            secret_store_id=d.get('secret_store_id'),
13332            tags=d.get('tags'),
13333            username=d.get('username'),
13334        )
13335
13336
13337class UpdateResponseMetadata:
13338    '''
13339     UpdateResponseMetadata is reserved for future use.
13340    '''
13341    __slots__ = []
13342
13343    def __init__(self, ):
13344        pass
13345
13346    def __repr__(self):
13347        return '<sdm.UpdateResponseMetadata ' + \
13348            '>'
13349
13350    def to_dict(self):
13351        return {}
13352
13353    @classmethod
13354    def from_dict(cls, d):
13355        return cls()
13356
13357
13358class User:
13359    '''
13360     A User can connect to resources they are granted directly, or granted
13361     via roles.
13362    '''
13363    __slots__ = [
13364        'email',
13365        'first_name',
13366        'id',
13367        'last_name',
13368        'suspended',
13369        'tags',
13370    ]
13371
13372    def __init__(
13373        self,
13374        email=None,
13375        first_name=None,
13376        id=None,
13377        last_name=None,
13378        suspended=None,
13379        tags=None,
13380    ):
13381        self.email = email if email is not None else ''
13382        '''
13383         The User's email address. Must be unique.
13384        '''
13385        self.first_name = first_name if first_name is not None else ''
13386        '''
13387         The User's first name.
13388        '''
13389        self.id = id if id is not None else ''
13390        '''
13391         Unique identifier of the User.
13392        '''
13393        self.last_name = last_name if last_name is not None else ''
13394        '''
13395         The User's last name.
13396        '''
13397        self.suspended = suspended if suspended is not None else False
13398        '''
13399         The User's suspended state.
13400        '''
13401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13402        '''
13403         Tags is a map of key, value pairs.
13404        '''
13405
13406    def __repr__(self):
13407        return '<sdm.User ' + \
13408            'email: ' + repr(self.email) + ' ' +\
13409            'first_name: ' + repr(self.first_name) + ' ' +\
13410            'id: ' + repr(self.id) + ' ' +\
13411            'last_name: ' + repr(self.last_name) + ' ' +\
13412            'suspended: ' + repr(self.suspended) + ' ' +\
13413            'tags: ' + repr(self.tags) + ' ' +\
13414            '>'
13415
13416    def to_dict(self):
13417        return {
13418            'email': self.email,
13419            'first_name': self.first_name,
13420            'id': self.id,
13421            'last_name': self.last_name,
13422            'suspended': self.suspended,
13423            'tags': self.tags,
13424        }
13425
13426    @classmethod
13427    def from_dict(cls, d):
13428        return cls(
13429            email=d.get('email'),
13430            first_name=d.get('first_name'),
13431            id=d.get('id'),
13432            last_name=d.get('last_name'),
13433            suspended=d.get('suspended'),
13434            tags=d.get('tags'),
13435        )
13436
13437
13438class VaultAppRoleStore:
13439    '''
13440
13441    '''
13442    __slots__ = [
13443        'id',
13444        'name',
13445        'namespace',
13446        'server_address',
13447        'tags',
13448    ]
13449
13450    def __init__(
13451        self,
13452        id=None,
13453        name=None,
13454        namespace=None,
13455        server_address=None,
13456        tags=None,
13457    ):
13458        self.id = id if id is not None else ''
13459        '''
13460         Unique identifier of the SecretStore.
13461        '''
13462        self.name = name if name is not None else ''
13463        '''
13464         Unique human-readable name of the SecretStore.
13465        '''
13466        self.namespace = namespace if namespace is not None else ''
13467        '''
13468
13469        '''
13470        self.server_address = server_address if server_address is not None else ''
13471        '''
13472
13473        '''
13474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13475        '''
13476         Tags is a map of key, value pairs.
13477        '''
13478
13479    def __repr__(self):
13480        return '<sdm.VaultAppRoleStore ' + \
13481            'id: ' + repr(self.id) + ' ' +\
13482            'name: ' + repr(self.name) + ' ' +\
13483            'namespace: ' + repr(self.namespace) + ' ' +\
13484            'server_address: ' + repr(self.server_address) + ' ' +\
13485            'tags: ' + repr(self.tags) + ' ' +\
13486            '>'
13487
13488    def to_dict(self):
13489        return {
13490            'id': self.id,
13491            'name': self.name,
13492            'namespace': self.namespace,
13493            'server_address': self.server_address,
13494            'tags': self.tags,
13495        }
13496
13497    @classmethod
13498    def from_dict(cls, d):
13499        return cls(
13500            id=d.get('id'),
13501            name=d.get('name'),
13502            namespace=d.get('namespace'),
13503            server_address=d.get('server_address'),
13504            tags=d.get('tags'),
13505        )
13506
13507
13508class VaultTLSStore:
13509    '''
13510
13511    '''
13512    __slots__ = [
13513        'ca_cert_path',
13514        'client_cert_path',
13515        'client_key_path',
13516        'id',
13517        'name',
13518        'namespace',
13519        'server_address',
13520        'tags',
13521    ]
13522
13523    def __init__(
13524        self,
13525        ca_cert_path=None,
13526        client_cert_path=None,
13527        client_key_path=None,
13528        id=None,
13529        name=None,
13530        namespace=None,
13531        server_address=None,
13532        tags=None,
13533    ):
13534        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13535        '''
13536
13537        '''
13538        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13539        '''
13540
13541        '''
13542        self.client_key_path = client_key_path if client_key_path is not None else ''
13543        '''
13544
13545        '''
13546        self.id = id if id is not None else ''
13547        '''
13548         Unique identifier of the SecretStore.
13549        '''
13550        self.name = name if name is not None else ''
13551        '''
13552         Unique human-readable name of the SecretStore.
13553        '''
13554        self.namespace = namespace if namespace is not None else ''
13555        '''
13556
13557        '''
13558        self.server_address = server_address if server_address is not None else ''
13559        '''
13560
13561        '''
13562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13563        '''
13564         Tags is a map of key, value pairs.
13565        '''
13566
13567    def __repr__(self):
13568        return '<sdm.VaultTLSStore ' + \
13569            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13570            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13571            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13572            'id: ' + repr(self.id) + ' ' +\
13573            'name: ' + repr(self.name) + ' ' +\
13574            'namespace: ' + repr(self.namespace) + ' ' +\
13575            'server_address: ' + repr(self.server_address) + ' ' +\
13576            'tags: ' + repr(self.tags) + ' ' +\
13577            '>'
13578
13579    def to_dict(self):
13580        return {
13581            'ca_cert_path': self.ca_cert_path,
13582            'client_cert_path': self.client_cert_path,
13583            'client_key_path': self.client_key_path,
13584            'id': self.id,
13585            'name': self.name,
13586            'namespace': self.namespace,
13587            'server_address': self.server_address,
13588            'tags': self.tags,
13589        }
13590
13591    @classmethod
13592    def from_dict(cls, d):
13593        return cls(
13594            ca_cert_path=d.get('ca_cert_path'),
13595            client_cert_path=d.get('client_cert_path'),
13596            client_key_path=d.get('client_key_path'),
13597            id=d.get('id'),
13598            name=d.get('name'),
13599            namespace=d.get('namespace'),
13600            server_address=d.get('server_address'),
13601            tags=d.get('tags'),
13602        )
13603
13604
13605class VaultTokenStore:
13606    '''
13607
13608    '''
13609    __slots__ = [
13610        'id',
13611        'name',
13612        'namespace',
13613        'server_address',
13614        'tags',
13615    ]
13616
13617    def __init__(
13618        self,
13619        id=None,
13620        name=None,
13621        namespace=None,
13622        server_address=None,
13623        tags=None,
13624    ):
13625        self.id = id if id is not None else ''
13626        '''
13627         Unique identifier of the SecretStore.
13628        '''
13629        self.name = name if name is not None else ''
13630        '''
13631         Unique human-readable name of the SecretStore.
13632        '''
13633        self.namespace = namespace if namespace is not None else ''
13634        '''
13635
13636        '''
13637        self.server_address = server_address if server_address is not None else ''
13638        '''
13639
13640        '''
13641        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13642        '''
13643         Tags is a map of key, value pairs.
13644        '''
13645
13646    def __repr__(self):
13647        return '<sdm.VaultTokenStore ' + \
13648            'id: ' + repr(self.id) + ' ' +\
13649            'name: ' + repr(self.name) + ' ' +\
13650            'namespace: ' + repr(self.namespace) + ' ' +\
13651            'server_address: ' + repr(self.server_address) + ' ' +\
13652            'tags: ' + repr(self.tags) + ' ' +\
13653            '>'
13654
13655    def to_dict(self):
13656        return {
13657            'id': self.id,
13658            'name': self.name,
13659            'namespace': self.namespace,
13660            'server_address': self.server_address,
13661            'tags': self.tags,
13662        }
13663
13664    @classmethod
13665    def from_dict(cls, d):
13666        return cls(
13667            id=d.get('id'),
13668            name=d.get('name'),
13669            namespace=d.get('namespace'),
13670            server_address=d.get('server_address'),
13671            tags=d.get('tags'),
13672        )
13673
13674
13675def _porcelain_zero_value_tags():
13676    return {}
13677
13678
13679def _porcelain_zero_value_access_rules():
13680    return []
class AKS:
 22class AKS:
 23    '''
 24
 25    '''
 26    __slots__ = [
 27        'bind_interface',
 28        'certificate_authority',
 29        'client_certificate',
 30        'client_key',
 31        'egress_filter',
 32        'healthcheck_namespace',
 33        'healthy',
 34        'hostname',
 35        'id',
 36        'name',
 37        'port',
 38        'port_override',
 39        'remote_identity_group_id',
 40        'remote_identity_healthcheck_username',
 41        'secret_store_id',
 42        'tags',
 43    ]
 44
 45    def __init__(
 46        self,
 47        bind_interface=None,
 48        certificate_authority=None,
 49        client_certificate=None,
 50        client_key=None,
 51        egress_filter=None,
 52        healthcheck_namespace=None,
 53        healthy=None,
 54        hostname=None,
 55        id=None,
 56        name=None,
 57        port=None,
 58        port_override=None,
 59        remote_identity_group_id=None,
 60        remote_identity_healthcheck_username=None,
 61        secret_store_id=None,
 62        tags=None,
 63    ):
 64        self.bind_interface = bind_interface if bind_interface is not None else ''
 65        '''
 66         Bind interface
 67        '''
 68        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 69        '''
 70
 71        '''
 72        self.client_certificate = client_certificate if client_certificate is not None else ''
 73        '''
 74
 75        '''
 76        self.client_key = client_key if client_key is not None else ''
 77        '''
 78
 79        '''
 80        self.egress_filter = egress_filter if egress_filter is not None else ''
 81        '''
 82         A filter applied to the routing logic to pin datasource to nodes.
 83        '''
 84        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 85        '''
 86         The path used to check the health of your connection.  Defaults to `default`.
 87        '''
 88        self.healthy = healthy if healthy is not None else False
 89        '''
 90         True if the datasource is reachable and the credentials are valid.
 91        '''
 92        self.hostname = hostname if hostname is not None else ''
 93        '''
 94
 95        '''
 96        self.id = id if id is not None else ''
 97        '''
 98         Unique identifier of the Resource.
 99        '''
100        self.name = name if name is not None else ''
101        '''
102         Unique human-readable name of the Resource.
103        '''
104        self.port = port if port is not None else 0
105        '''
106
107        '''
108        self.port_override = port_override if port_override is not None else 0
109        '''
110
111        '''
112        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
113        '''
114
115        '''
116        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
117        '''
118
119        '''
120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
121        '''
122         ID of the secret store containing credentials for this resource, if any.
123        '''
124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
125        '''
126         Tags is a map of key, value pairs.
127        '''
128
129    def __repr__(self):
130        return '<sdm.AKS ' + \
131            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
132            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
133            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
134            'client_key: ' + repr(self.client_key) + ' ' +\
135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
136            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
137            'healthy: ' + repr(self.healthy) + ' ' +\
138            'hostname: ' + repr(self.hostname) + ' ' +\
139            'id: ' + repr(self.id) + ' ' +\
140            'name: ' + repr(self.name) + ' ' +\
141            'port: ' + repr(self.port) + ' ' +\
142            'port_override: ' + repr(self.port_override) + ' ' +\
143            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
144            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
146            'tags: ' + repr(self.tags) + ' ' +\
147            '>'
148
149    def to_dict(self):
150        return {
151            'bind_interface': self.bind_interface,
152            'certificate_authority': self.certificate_authority,
153            'client_certificate': self.client_certificate,
154            'client_key': self.client_key,
155            'egress_filter': self.egress_filter,
156            'healthcheck_namespace': self.healthcheck_namespace,
157            'healthy': self.healthy,
158            'hostname': self.hostname,
159            'id': self.id,
160            'name': self.name,
161            'port': self.port,
162            'port_override': self.port_override,
163            'remote_identity_group_id': self.remote_identity_group_id,
164            'remote_identity_healthcheck_username':
165            self.remote_identity_healthcheck_username,
166            'secret_store_id': self.secret_store_id,
167            'tags': self.tags,
168        }
169
170    @classmethod
171    def from_dict(cls, d):
172        return cls(
173            bind_interface=d.get('bind_interface'),
174            certificate_authority=d.get('certificate_authority'),
175            client_certificate=d.get('client_certificate'),
176            client_key=d.get('client_key'),
177            egress_filter=d.get('egress_filter'),
178            healthcheck_namespace=d.get('healthcheck_namespace'),
179            healthy=d.get('healthy'),
180            hostname=d.get('hostname'),
181            id=d.get('id'),
182            name=d.get('name'),
183            port=d.get('port'),
184            port_override=d.get('port_override'),
185            remote_identity_group_id=d.get('remote_identity_group_id'),
186            remote_identity_healthcheck_username=d.get(
187                'remote_identity_healthcheck_username'),
188            secret_store_id=d.get('secret_store_id'),
189            tags=d.get('tags'),
190        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 45    def __init__(
 46        self,
 47        bind_interface=None,
 48        certificate_authority=None,
 49        client_certificate=None,
 50        client_key=None,
 51        egress_filter=None,
 52        healthcheck_namespace=None,
 53        healthy=None,
 54        hostname=None,
 55        id=None,
 56        name=None,
 57        port=None,
 58        port_override=None,
 59        remote_identity_group_id=None,
 60        remote_identity_healthcheck_username=None,
 61        secret_store_id=None,
 62        tags=None,
 63    ):
 64        self.bind_interface = bind_interface if bind_interface is not None else ''
 65        '''
 66         Bind interface
 67        '''
 68        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 69        '''
 70
 71        '''
 72        self.client_certificate = client_certificate if client_certificate is not None else ''
 73        '''
 74
 75        '''
 76        self.client_key = client_key if client_key is not None else ''
 77        '''
 78
 79        '''
 80        self.egress_filter = egress_filter if egress_filter is not None else ''
 81        '''
 82         A filter applied to the routing logic to pin datasource to nodes.
 83        '''
 84        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 85        '''
 86         The path used to check the health of your connection.  Defaults to `default`.
 87        '''
 88        self.healthy = healthy if healthy is not None else False
 89        '''
 90         True if the datasource is reachable and the credentials are valid.
 91        '''
 92        self.hostname = hostname if hostname is not None else ''
 93        '''
 94
 95        '''
 96        self.id = id if id is not None else ''
 97        '''
 98         Unique identifier of the Resource.
 99        '''
100        self.name = name if name is not None else ''
101        '''
102         Unique human-readable name of the Resource.
103        '''
104        self.port = port if port is not None else 0
105        '''
106
107        '''
108        self.port_override = port_override if port_override is not None else 0
109        '''
110
111        '''
112        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
113        '''
114
115        '''
116        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
117        '''
118
119        '''
120        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
121        '''
122         ID of the secret store containing credentials for this resource, if any.
123        '''
124        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
125        '''
126         Tags is a map of key, value pairs.
127        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
149    def to_dict(self):
150        return {
151            'bind_interface': self.bind_interface,
152            'certificate_authority': self.certificate_authority,
153            'client_certificate': self.client_certificate,
154            'client_key': self.client_key,
155            'egress_filter': self.egress_filter,
156            'healthcheck_namespace': self.healthcheck_namespace,
157            'healthy': self.healthy,
158            'hostname': self.hostname,
159            'id': self.id,
160            'name': self.name,
161            'port': self.port,
162            'port_override': self.port_override,
163            'remote_identity_group_id': self.remote_identity_group_id,
164            'remote_identity_healthcheck_username':
165            self.remote_identity_healthcheck_username,
166            'secret_store_id': self.secret_store_id,
167            'tags': self.tags,
168        }
@classmethod
def from_dict(cls, d)
170    @classmethod
171    def from_dict(cls, d):
172        return cls(
173            bind_interface=d.get('bind_interface'),
174            certificate_authority=d.get('certificate_authority'),
175            client_certificate=d.get('client_certificate'),
176            client_key=d.get('client_key'),
177            egress_filter=d.get('egress_filter'),
178            healthcheck_namespace=d.get('healthcheck_namespace'),
179            healthy=d.get('healthy'),
180            hostname=d.get('hostname'),
181            id=d.get('id'),
182            name=d.get('name'),
183            port=d.get('port'),
184            port_override=d.get('port_override'),
185            remote_identity_group_id=d.get('remote_identity_group_id'),
186            remote_identity_healthcheck_username=d.get(
187                'remote_identity_healthcheck_username'),
188            secret_store_id=d.get('secret_store_id'),
189            tags=d.get('tags'),
190        )
class AKSBasicAuth:
193class AKSBasicAuth:
194    '''
195
196    '''
197    __slots__ = [
198        'bind_interface',
199        'egress_filter',
200        'healthcheck_namespace',
201        'healthy',
202        'hostname',
203        'id',
204        'name',
205        'password',
206        'port',
207        'port_override',
208        'secret_store_id',
209        'tags',
210        'username',
211    ]
212
213    def __init__(
214        self,
215        bind_interface=None,
216        egress_filter=None,
217        healthcheck_namespace=None,
218        healthy=None,
219        hostname=None,
220        id=None,
221        name=None,
222        password=None,
223        port=None,
224        port_override=None,
225        secret_store_id=None,
226        tags=None,
227        username=None,
228    ):
229        self.bind_interface = bind_interface if bind_interface is not None else ''
230        '''
231         Bind interface
232        '''
233        self.egress_filter = egress_filter if egress_filter is not None else ''
234        '''
235         A filter applied to the routing logic to pin datasource to nodes.
236        '''
237        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
238        '''
239         The path used to check the health of your connection.  Defaults to `default`.
240        '''
241        self.healthy = healthy if healthy is not None else False
242        '''
243         True if the datasource is reachable and the credentials are valid.
244        '''
245        self.hostname = hostname if hostname is not None else ''
246        '''
247
248        '''
249        self.id = id if id is not None else ''
250        '''
251         Unique identifier of the Resource.
252        '''
253        self.name = name if name is not None else ''
254        '''
255         Unique human-readable name of the Resource.
256        '''
257        self.password = password if password is not None else ''
258        '''
259
260        '''
261        self.port = port if port is not None else 0
262        '''
263
264        '''
265        self.port_override = port_override if port_override is not None else 0
266        '''
267
268        '''
269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
270        '''
271         ID of the secret store containing credentials for this resource, if any.
272        '''
273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
274        '''
275         Tags is a map of key, value pairs.
276        '''
277        self.username = username if username is not None else ''
278        '''
279
280        '''
281
282    def __repr__(self):
283        return '<sdm.AKSBasicAuth ' + \
284            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
285            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
286            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
287            'healthy: ' + repr(self.healthy) + ' ' +\
288            'hostname: ' + repr(self.hostname) + ' ' +\
289            'id: ' + repr(self.id) + ' ' +\
290            'name: ' + repr(self.name) + ' ' +\
291            'password: ' + repr(self.password) + ' ' +\
292            'port: ' + repr(self.port) + ' ' +\
293            'port_override: ' + repr(self.port_override) + ' ' +\
294            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
295            'tags: ' + repr(self.tags) + ' ' +\
296            'username: ' + repr(self.username) + ' ' +\
297            '>'
298
299    def to_dict(self):
300        return {
301            'bind_interface': self.bind_interface,
302            'egress_filter': self.egress_filter,
303            'healthcheck_namespace': self.healthcheck_namespace,
304            'healthy': self.healthy,
305            'hostname': self.hostname,
306            'id': self.id,
307            'name': self.name,
308            'password': self.password,
309            'port': self.port,
310            'port_override': self.port_override,
311            'secret_store_id': self.secret_store_id,
312            'tags': self.tags,
313            'username': self.username,
314        }
315
316    @classmethod
317    def from_dict(cls, d):
318        return cls(
319            bind_interface=d.get('bind_interface'),
320            egress_filter=d.get('egress_filter'),
321            healthcheck_namespace=d.get('healthcheck_namespace'),
322            healthy=d.get('healthy'),
323            hostname=d.get('hostname'),
324            id=d.get('id'),
325            name=d.get('name'),
326            password=d.get('password'),
327            port=d.get('port'),
328            port_override=d.get('port_override'),
329            secret_store_id=d.get('secret_store_id'),
330            tags=d.get('tags'),
331            username=d.get('username'),
332        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
213    def __init__(
214        self,
215        bind_interface=None,
216        egress_filter=None,
217        healthcheck_namespace=None,
218        healthy=None,
219        hostname=None,
220        id=None,
221        name=None,
222        password=None,
223        port=None,
224        port_override=None,
225        secret_store_id=None,
226        tags=None,
227        username=None,
228    ):
229        self.bind_interface = bind_interface if bind_interface is not None else ''
230        '''
231         Bind interface
232        '''
233        self.egress_filter = egress_filter if egress_filter is not None else ''
234        '''
235         A filter applied to the routing logic to pin datasource to nodes.
236        '''
237        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
238        '''
239         The path used to check the health of your connection.  Defaults to `default`.
240        '''
241        self.healthy = healthy if healthy is not None else False
242        '''
243         True if the datasource is reachable and the credentials are valid.
244        '''
245        self.hostname = hostname if hostname is not None else ''
246        '''
247
248        '''
249        self.id = id if id is not None else ''
250        '''
251         Unique identifier of the Resource.
252        '''
253        self.name = name if name is not None else ''
254        '''
255         Unique human-readable name of the Resource.
256        '''
257        self.password = password if password is not None else ''
258        '''
259
260        '''
261        self.port = port if port is not None else 0
262        '''
263
264        '''
265        self.port_override = port_override if port_override is not None else 0
266        '''
267
268        '''
269        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
270        '''
271         ID of the secret store containing credentials for this resource, if any.
272        '''
273        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
274        '''
275         Tags is a map of key, value pairs.
276        '''
277        self.username = username if username is not None else ''
278        '''
279
280        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
299    def to_dict(self):
300        return {
301            'bind_interface': self.bind_interface,
302            'egress_filter': self.egress_filter,
303            'healthcheck_namespace': self.healthcheck_namespace,
304            'healthy': self.healthy,
305            'hostname': self.hostname,
306            'id': self.id,
307            'name': self.name,
308            'password': self.password,
309            'port': self.port,
310            'port_override': self.port_override,
311            'secret_store_id': self.secret_store_id,
312            'tags': self.tags,
313            'username': self.username,
314        }
@classmethod
def from_dict(cls, d)
316    @classmethod
317    def from_dict(cls, d):
318        return cls(
319            bind_interface=d.get('bind_interface'),
320            egress_filter=d.get('egress_filter'),
321            healthcheck_namespace=d.get('healthcheck_namespace'),
322            healthy=d.get('healthy'),
323            hostname=d.get('hostname'),
324            id=d.get('id'),
325            name=d.get('name'),
326            password=d.get('password'),
327            port=d.get('port'),
328            port_override=d.get('port_override'),
329            secret_store_id=d.get('secret_store_id'),
330            tags=d.get('tags'),
331            username=d.get('username'),
332        )
class AKSServiceAccount:
335class AKSServiceAccount:
336    '''
337
338    '''
339    __slots__ = [
340        'bind_interface',
341        'egress_filter',
342        'healthcheck_namespace',
343        'healthy',
344        'hostname',
345        'id',
346        'name',
347        'port',
348        'port_override',
349        'remote_identity_group_id',
350        'remote_identity_healthcheck_username',
351        'secret_store_id',
352        'tags',
353        'token',
354    ]
355
356    def __init__(
357        self,
358        bind_interface=None,
359        egress_filter=None,
360        healthcheck_namespace=None,
361        healthy=None,
362        hostname=None,
363        id=None,
364        name=None,
365        port=None,
366        port_override=None,
367        remote_identity_group_id=None,
368        remote_identity_healthcheck_username=None,
369        secret_store_id=None,
370        tags=None,
371        token=None,
372    ):
373        self.bind_interface = bind_interface if bind_interface is not None else ''
374        '''
375         Bind interface
376        '''
377        self.egress_filter = egress_filter if egress_filter is not None else ''
378        '''
379         A filter applied to the routing logic to pin datasource to nodes.
380        '''
381        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
382        '''
383         The path used to check the health of your connection.  Defaults to `default`.
384        '''
385        self.healthy = healthy if healthy is not None else False
386        '''
387         True if the datasource is reachable and the credentials are valid.
388        '''
389        self.hostname = hostname if hostname is not None else ''
390        '''
391
392        '''
393        self.id = id if id is not None else ''
394        '''
395         Unique identifier of the Resource.
396        '''
397        self.name = name if name is not None else ''
398        '''
399         Unique human-readable name of the Resource.
400        '''
401        self.port = port if port is not None else 0
402        '''
403
404        '''
405        self.port_override = port_override if port_override is not None else 0
406        '''
407
408        '''
409        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
410        '''
411
412        '''
413        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
414        '''
415
416        '''
417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
418        '''
419         ID of the secret store containing credentials for this resource, if any.
420        '''
421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
422        '''
423         Tags is a map of key, value pairs.
424        '''
425        self.token = token if token is not None else ''
426        '''
427
428        '''
429
430    def __repr__(self):
431        return '<sdm.AKSServiceAccount ' + \
432            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
433            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
434            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
435            'healthy: ' + repr(self.healthy) + ' ' +\
436            'hostname: ' + repr(self.hostname) + ' ' +\
437            'id: ' + repr(self.id) + ' ' +\
438            'name: ' + repr(self.name) + ' ' +\
439            'port: ' + repr(self.port) + ' ' +\
440            'port_override: ' + repr(self.port_override) + ' ' +\
441            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
442            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
443            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
444            'tags: ' + repr(self.tags) + ' ' +\
445            'token: ' + repr(self.token) + ' ' +\
446            '>'
447
448    def to_dict(self):
449        return {
450            'bind_interface': self.bind_interface,
451            'egress_filter': self.egress_filter,
452            'healthcheck_namespace': self.healthcheck_namespace,
453            'healthy': self.healthy,
454            'hostname': self.hostname,
455            'id': self.id,
456            'name': self.name,
457            'port': self.port,
458            'port_override': self.port_override,
459            'remote_identity_group_id': self.remote_identity_group_id,
460            'remote_identity_healthcheck_username':
461            self.remote_identity_healthcheck_username,
462            'secret_store_id': self.secret_store_id,
463            'tags': self.tags,
464            'token': self.token,
465        }
466
467    @classmethod
468    def from_dict(cls, d):
469        return cls(
470            bind_interface=d.get('bind_interface'),
471            egress_filter=d.get('egress_filter'),
472            healthcheck_namespace=d.get('healthcheck_namespace'),
473            healthy=d.get('healthy'),
474            hostname=d.get('hostname'),
475            id=d.get('id'),
476            name=d.get('name'),
477            port=d.get('port'),
478            port_override=d.get('port_override'),
479            remote_identity_group_id=d.get('remote_identity_group_id'),
480            remote_identity_healthcheck_username=d.get(
481                'remote_identity_healthcheck_username'),
482            secret_store_id=d.get('secret_store_id'),
483            tags=d.get('tags'),
484            token=d.get('token'),
485        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
356    def __init__(
357        self,
358        bind_interface=None,
359        egress_filter=None,
360        healthcheck_namespace=None,
361        healthy=None,
362        hostname=None,
363        id=None,
364        name=None,
365        port=None,
366        port_override=None,
367        remote_identity_group_id=None,
368        remote_identity_healthcheck_username=None,
369        secret_store_id=None,
370        tags=None,
371        token=None,
372    ):
373        self.bind_interface = bind_interface if bind_interface is not None else ''
374        '''
375         Bind interface
376        '''
377        self.egress_filter = egress_filter if egress_filter is not None else ''
378        '''
379         A filter applied to the routing logic to pin datasource to nodes.
380        '''
381        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
382        '''
383         The path used to check the health of your connection.  Defaults to `default`.
384        '''
385        self.healthy = healthy if healthy is not None else False
386        '''
387         True if the datasource is reachable and the credentials are valid.
388        '''
389        self.hostname = hostname if hostname is not None else ''
390        '''
391
392        '''
393        self.id = id if id is not None else ''
394        '''
395         Unique identifier of the Resource.
396        '''
397        self.name = name if name is not None else ''
398        '''
399         Unique human-readable name of the Resource.
400        '''
401        self.port = port if port is not None else 0
402        '''
403
404        '''
405        self.port_override = port_override if port_override is not None else 0
406        '''
407
408        '''
409        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
410        '''
411
412        '''
413        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
414        '''
415
416        '''
417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
418        '''
419         ID of the secret store containing credentials for this resource, if any.
420        '''
421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
422        '''
423         Tags is a map of key, value pairs.
424        '''
425        self.token = token if token is not None else ''
426        '''
427
428        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
448    def to_dict(self):
449        return {
450            'bind_interface': self.bind_interface,
451            'egress_filter': self.egress_filter,
452            'healthcheck_namespace': self.healthcheck_namespace,
453            'healthy': self.healthy,
454            'hostname': self.hostname,
455            'id': self.id,
456            'name': self.name,
457            'port': self.port,
458            'port_override': self.port_override,
459            'remote_identity_group_id': self.remote_identity_group_id,
460            'remote_identity_healthcheck_username':
461            self.remote_identity_healthcheck_username,
462            'secret_store_id': self.secret_store_id,
463            'tags': self.tags,
464            'token': self.token,
465        }
@classmethod
def from_dict(cls, d)
467    @classmethod
468    def from_dict(cls, d):
469        return cls(
470            bind_interface=d.get('bind_interface'),
471            egress_filter=d.get('egress_filter'),
472            healthcheck_namespace=d.get('healthcheck_namespace'),
473            healthy=d.get('healthy'),
474            hostname=d.get('hostname'),
475            id=d.get('id'),
476            name=d.get('name'),
477            port=d.get('port'),
478            port_override=d.get('port_override'),
479            remote_identity_group_id=d.get('remote_identity_group_id'),
480            remote_identity_healthcheck_username=d.get(
481                'remote_identity_healthcheck_username'),
482            secret_store_id=d.get('secret_store_id'),
483            tags=d.get('tags'),
484            token=d.get('token'),
485        )
class AKSServiceAccountUserImpersonation:
488class AKSServiceAccountUserImpersonation:
489    '''
490
491    '''
492    __slots__ = [
493        'bind_interface',
494        'egress_filter',
495        'healthcheck_namespace',
496        'healthy',
497        'hostname',
498        'id',
499        'name',
500        'port',
501        'port_override',
502        'secret_store_id',
503        'tags',
504        'token',
505    ]
506
507    def __init__(
508        self,
509        bind_interface=None,
510        egress_filter=None,
511        healthcheck_namespace=None,
512        healthy=None,
513        hostname=None,
514        id=None,
515        name=None,
516        port=None,
517        port_override=None,
518        secret_store_id=None,
519        tags=None,
520        token=None,
521    ):
522        self.bind_interface = bind_interface if bind_interface is not None else ''
523        '''
524         Bind interface
525        '''
526        self.egress_filter = egress_filter if egress_filter is not None else ''
527        '''
528         A filter applied to the routing logic to pin datasource to nodes.
529        '''
530        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
531        '''
532         The path used to check the health of your connection.  Defaults to `default`.
533        '''
534        self.healthy = healthy if healthy is not None else False
535        '''
536         True if the datasource is reachable and the credentials are valid.
537        '''
538        self.hostname = hostname if hostname is not None else ''
539        '''
540
541        '''
542        self.id = id if id is not None else ''
543        '''
544         Unique identifier of the Resource.
545        '''
546        self.name = name if name is not None else ''
547        '''
548         Unique human-readable name of the Resource.
549        '''
550        self.port = port if port is not None else 0
551        '''
552
553        '''
554        self.port_override = port_override if port_override is not None else 0
555        '''
556
557        '''
558        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
559        '''
560         ID of the secret store containing credentials for this resource, if any.
561        '''
562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
563        '''
564         Tags is a map of key, value pairs.
565        '''
566        self.token = token if token is not None else ''
567        '''
568
569        '''
570
571    def __repr__(self):
572        return '<sdm.AKSServiceAccountUserImpersonation ' + \
573            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
574            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
575            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
576            'healthy: ' + repr(self.healthy) + ' ' +\
577            'hostname: ' + repr(self.hostname) + ' ' +\
578            'id: ' + repr(self.id) + ' ' +\
579            'name: ' + repr(self.name) + ' ' +\
580            'port: ' + repr(self.port) + ' ' +\
581            'port_override: ' + repr(self.port_override) + ' ' +\
582            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
583            'tags: ' + repr(self.tags) + ' ' +\
584            'token: ' + repr(self.token) + ' ' +\
585            '>'
586
587    def to_dict(self):
588        return {
589            'bind_interface': self.bind_interface,
590            'egress_filter': self.egress_filter,
591            'healthcheck_namespace': self.healthcheck_namespace,
592            'healthy': self.healthy,
593            'hostname': self.hostname,
594            'id': self.id,
595            'name': self.name,
596            'port': self.port,
597            'port_override': self.port_override,
598            'secret_store_id': self.secret_store_id,
599            'tags': self.tags,
600            'token': self.token,
601        }
602
603    @classmethod
604    def from_dict(cls, d):
605        return cls(
606            bind_interface=d.get('bind_interface'),
607            egress_filter=d.get('egress_filter'),
608            healthcheck_namespace=d.get('healthcheck_namespace'),
609            healthy=d.get('healthy'),
610            hostname=d.get('hostname'),
611            id=d.get('id'),
612            name=d.get('name'),
613            port=d.get('port'),
614            port_override=d.get('port_override'),
615            secret_store_id=d.get('secret_store_id'),
616            tags=d.get('tags'),
617            token=d.get('token'),
618        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
507    def __init__(
508        self,
509        bind_interface=None,
510        egress_filter=None,
511        healthcheck_namespace=None,
512        healthy=None,
513        hostname=None,
514        id=None,
515        name=None,
516        port=None,
517        port_override=None,
518        secret_store_id=None,
519        tags=None,
520        token=None,
521    ):
522        self.bind_interface = bind_interface if bind_interface is not None else ''
523        '''
524         Bind interface
525        '''
526        self.egress_filter = egress_filter if egress_filter is not None else ''
527        '''
528         A filter applied to the routing logic to pin datasource to nodes.
529        '''
530        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
531        '''
532         The path used to check the health of your connection.  Defaults to `default`.
533        '''
534        self.healthy = healthy if healthy is not None else False
535        '''
536         True if the datasource is reachable and the credentials are valid.
537        '''
538        self.hostname = hostname if hostname is not None else ''
539        '''
540
541        '''
542        self.id = id if id is not None else ''
543        '''
544         Unique identifier of the Resource.
545        '''
546        self.name = name if name is not None else ''
547        '''
548         Unique human-readable name of the Resource.
549        '''
550        self.port = port if port is not None else 0
551        '''
552
553        '''
554        self.port_override = port_override if port_override is not None else 0
555        '''
556
557        '''
558        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
559        '''
560         ID of the secret store containing credentials for this resource, if any.
561        '''
562        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
563        '''
564         Tags is a map of key, value pairs.
565        '''
566        self.token = token if token is not None else ''
567        '''
568
569        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
587    def to_dict(self):
588        return {
589            'bind_interface': self.bind_interface,
590            'egress_filter': self.egress_filter,
591            'healthcheck_namespace': self.healthcheck_namespace,
592            'healthy': self.healthy,
593            'hostname': self.hostname,
594            'id': self.id,
595            'name': self.name,
596            'port': self.port,
597            'port_override': self.port_override,
598            'secret_store_id': self.secret_store_id,
599            'tags': self.tags,
600            'token': self.token,
601        }
@classmethod
def from_dict(cls, d)
603    @classmethod
604    def from_dict(cls, d):
605        return cls(
606            bind_interface=d.get('bind_interface'),
607            egress_filter=d.get('egress_filter'),
608            healthcheck_namespace=d.get('healthcheck_namespace'),
609            healthy=d.get('healthy'),
610            hostname=d.get('hostname'),
611            id=d.get('id'),
612            name=d.get('name'),
613            port=d.get('port'),
614            port_override=d.get('port_override'),
615            secret_store_id=d.get('secret_store_id'),
616            tags=d.get('tags'),
617            token=d.get('token'),
618        )
class AKSUserImpersonation:
621class AKSUserImpersonation:
622    '''
623
624    '''
625    __slots__ = [
626        'bind_interface',
627        'certificate_authority',
628        'client_certificate',
629        'client_key',
630        'egress_filter',
631        'healthcheck_namespace',
632        'healthy',
633        'hostname',
634        'id',
635        'name',
636        'port',
637        'port_override',
638        'secret_store_id',
639        'tags',
640    ]
641
642    def __init__(
643        self,
644        bind_interface=None,
645        certificate_authority=None,
646        client_certificate=None,
647        client_key=None,
648        egress_filter=None,
649        healthcheck_namespace=None,
650        healthy=None,
651        hostname=None,
652        id=None,
653        name=None,
654        port=None,
655        port_override=None,
656        secret_store_id=None,
657        tags=None,
658    ):
659        self.bind_interface = bind_interface if bind_interface is not None else ''
660        '''
661         Bind interface
662        '''
663        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
664        '''
665
666        '''
667        self.client_certificate = client_certificate if client_certificate is not None else ''
668        '''
669
670        '''
671        self.client_key = client_key if client_key is not None else ''
672        '''
673
674        '''
675        self.egress_filter = egress_filter if egress_filter is not None else ''
676        '''
677         A filter applied to the routing logic to pin datasource to nodes.
678        '''
679        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
680        '''
681         The path used to check the health of your connection.  Defaults to `default`.
682        '''
683        self.healthy = healthy if healthy is not None else False
684        '''
685         True if the datasource is reachable and the credentials are valid.
686        '''
687        self.hostname = hostname if hostname is not None else ''
688        '''
689
690        '''
691        self.id = id if id is not None else ''
692        '''
693         Unique identifier of the Resource.
694        '''
695        self.name = name if name is not None else ''
696        '''
697         Unique human-readable name of the Resource.
698        '''
699        self.port = port if port is not None else 0
700        '''
701
702        '''
703        self.port_override = port_override if port_override is not None else 0
704        '''
705
706        '''
707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
708        '''
709         ID of the secret store containing credentials for this resource, if any.
710        '''
711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
712        '''
713         Tags is a map of key, value pairs.
714        '''
715
716    def __repr__(self):
717        return '<sdm.AKSUserImpersonation ' + \
718            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
719            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
720            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
721            'client_key: ' + repr(self.client_key) + ' ' +\
722            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
723            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
724            'healthy: ' + repr(self.healthy) + ' ' +\
725            'hostname: ' + repr(self.hostname) + ' ' +\
726            'id: ' + repr(self.id) + ' ' +\
727            'name: ' + repr(self.name) + ' ' +\
728            'port: ' + repr(self.port) + ' ' +\
729            'port_override: ' + repr(self.port_override) + ' ' +\
730            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
731            'tags: ' + repr(self.tags) + ' ' +\
732            '>'
733
734    def to_dict(self):
735        return {
736            'bind_interface': self.bind_interface,
737            'certificate_authority': self.certificate_authority,
738            'client_certificate': self.client_certificate,
739            'client_key': self.client_key,
740            'egress_filter': self.egress_filter,
741            'healthcheck_namespace': self.healthcheck_namespace,
742            'healthy': self.healthy,
743            'hostname': self.hostname,
744            'id': self.id,
745            'name': self.name,
746            'port': self.port,
747            'port_override': self.port_override,
748            'secret_store_id': self.secret_store_id,
749            'tags': self.tags,
750        }
751
752    @classmethod
753    def from_dict(cls, d):
754        return cls(
755            bind_interface=d.get('bind_interface'),
756            certificate_authority=d.get('certificate_authority'),
757            client_certificate=d.get('client_certificate'),
758            client_key=d.get('client_key'),
759            egress_filter=d.get('egress_filter'),
760            healthcheck_namespace=d.get('healthcheck_namespace'),
761            healthy=d.get('healthy'),
762            hostname=d.get('hostname'),
763            id=d.get('id'),
764            name=d.get('name'),
765            port=d.get('port'),
766            port_override=d.get('port_override'),
767            secret_store_id=d.get('secret_store_id'),
768            tags=d.get('tags'),
769        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
642    def __init__(
643        self,
644        bind_interface=None,
645        certificate_authority=None,
646        client_certificate=None,
647        client_key=None,
648        egress_filter=None,
649        healthcheck_namespace=None,
650        healthy=None,
651        hostname=None,
652        id=None,
653        name=None,
654        port=None,
655        port_override=None,
656        secret_store_id=None,
657        tags=None,
658    ):
659        self.bind_interface = bind_interface if bind_interface is not None else ''
660        '''
661         Bind interface
662        '''
663        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
664        '''
665
666        '''
667        self.client_certificate = client_certificate if client_certificate is not None else ''
668        '''
669
670        '''
671        self.client_key = client_key if client_key is not None else ''
672        '''
673
674        '''
675        self.egress_filter = egress_filter if egress_filter is not None else ''
676        '''
677         A filter applied to the routing logic to pin datasource to nodes.
678        '''
679        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
680        '''
681         The path used to check the health of your connection.  Defaults to `default`.
682        '''
683        self.healthy = healthy if healthy is not None else False
684        '''
685         True if the datasource is reachable and the credentials are valid.
686        '''
687        self.hostname = hostname if hostname is not None else ''
688        '''
689
690        '''
691        self.id = id if id is not None else ''
692        '''
693         Unique identifier of the Resource.
694        '''
695        self.name = name if name is not None else ''
696        '''
697         Unique human-readable name of the Resource.
698        '''
699        self.port = port if port is not None else 0
700        '''
701
702        '''
703        self.port_override = port_override if port_override is not None else 0
704        '''
705
706        '''
707        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
708        '''
709         ID of the secret store containing credentials for this resource, if any.
710        '''
711        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
712        '''
713         Tags is a map of key, value pairs.
714        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
734    def to_dict(self):
735        return {
736            'bind_interface': self.bind_interface,
737            'certificate_authority': self.certificate_authority,
738            'client_certificate': self.client_certificate,
739            'client_key': self.client_key,
740            'egress_filter': self.egress_filter,
741            'healthcheck_namespace': self.healthcheck_namespace,
742            'healthy': self.healthy,
743            'hostname': self.hostname,
744            'id': self.id,
745            'name': self.name,
746            'port': self.port,
747            'port_override': self.port_override,
748            'secret_store_id': self.secret_store_id,
749            'tags': self.tags,
750        }
@classmethod
def from_dict(cls, d)
752    @classmethod
753    def from_dict(cls, d):
754        return cls(
755            bind_interface=d.get('bind_interface'),
756            certificate_authority=d.get('certificate_authority'),
757            client_certificate=d.get('client_certificate'),
758            client_key=d.get('client_key'),
759            egress_filter=d.get('egress_filter'),
760            healthcheck_namespace=d.get('healthcheck_namespace'),
761            healthy=d.get('healthy'),
762            hostname=d.get('hostname'),
763            id=d.get('id'),
764            name=d.get('name'),
765            port=d.get('port'),
766            port_override=d.get('port_override'),
767            secret_store_id=d.get('secret_store_id'),
768            tags=d.get('tags'),
769        )
class AWS:
772class AWS:
773    '''
774
775    '''
776    __slots__ = [
777        'access_key',
778        'bind_interface',
779        'egress_filter',
780        'healthcheck_region',
781        'healthy',
782        'id',
783        'name',
784        'role_arn',
785        'role_external_id',
786        'secret_access_key',
787        'secret_store_id',
788        'tags',
789    ]
790
791    def __init__(
792        self,
793        access_key=None,
794        bind_interface=None,
795        egress_filter=None,
796        healthcheck_region=None,
797        healthy=None,
798        id=None,
799        name=None,
800        role_arn=None,
801        role_external_id=None,
802        secret_access_key=None,
803        secret_store_id=None,
804        tags=None,
805    ):
806        self.access_key = access_key if access_key is not None else ''
807        '''
808
809        '''
810        self.bind_interface = bind_interface if bind_interface is not None else ''
811        '''
812         Bind interface
813        '''
814        self.egress_filter = egress_filter if egress_filter is not None else ''
815        '''
816         A filter applied to the routing logic to pin datasource to nodes.
817        '''
818        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
819        '''
820
821        '''
822        self.healthy = healthy if healthy is not None else False
823        '''
824         True if the datasource is reachable and the credentials are valid.
825        '''
826        self.id = id if id is not None else ''
827        '''
828         Unique identifier of the Resource.
829        '''
830        self.name = name if name is not None else ''
831        '''
832         Unique human-readable name of the Resource.
833        '''
834        self.role_arn = role_arn if role_arn is not None else ''
835        '''
836
837        '''
838        self.role_external_id = role_external_id if role_external_id is not None else ''
839        '''
840
841        '''
842        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
843        '''
844
845        '''
846        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
847        '''
848         ID of the secret store containing credentials for this resource, if any.
849        '''
850        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
851        '''
852         Tags is a map of key, value pairs.
853        '''
854
855    def __repr__(self):
856        return '<sdm.AWS ' + \
857            'access_key: ' + repr(self.access_key) + ' ' +\
858            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
859            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
860            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
861            'healthy: ' + repr(self.healthy) + ' ' +\
862            'id: ' + repr(self.id) + ' ' +\
863            'name: ' + repr(self.name) + ' ' +\
864            'role_arn: ' + repr(self.role_arn) + ' ' +\
865            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
866            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
867            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
868            'tags: ' + repr(self.tags) + ' ' +\
869            '>'
870
871    def to_dict(self):
872        return {
873            'access_key': self.access_key,
874            'bind_interface': self.bind_interface,
875            'egress_filter': self.egress_filter,
876            'healthcheck_region': self.healthcheck_region,
877            'healthy': self.healthy,
878            'id': self.id,
879            'name': self.name,
880            'role_arn': self.role_arn,
881            'role_external_id': self.role_external_id,
882            'secret_access_key': self.secret_access_key,
883            'secret_store_id': self.secret_store_id,
884            'tags': self.tags,
885        }
886
887    @classmethod
888    def from_dict(cls, d):
889        return cls(
890            access_key=d.get('access_key'),
891            bind_interface=d.get('bind_interface'),
892            egress_filter=d.get('egress_filter'),
893            healthcheck_region=d.get('healthcheck_region'),
894            healthy=d.get('healthy'),
895            id=d.get('id'),
896            name=d.get('name'),
897            role_arn=d.get('role_arn'),
898            role_external_id=d.get('role_external_id'),
899            secret_access_key=d.get('secret_access_key'),
900            secret_store_id=d.get('secret_store_id'),
901            tags=d.get('tags'),
902        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
791    def __init__(
792        self,
793        access_key=None,
794        bind_interface=None,
795        egress_filter=None,
796        healthcheck_region=None,
797        healthy=None,
798        id=None,
799        name=None,
800        role_arn=None,
801        role_external_id=None,
802        secret_access_key=None,
803        secret_store_id=None,
804        tags=None,
805    ):
806        self.access_key = access_key if access_key is not None else ''
807        '''
808
809        '''
810        self.bind_interface = bind_interface if bind_interface is not None else ''
811        '''
812         Bind interface
813        '''
814        self.egress_filter = egress_filter if egress_filter is not None else ''
815        '''
816         A filter applied to the routing logic to pin datasource to nodes.
817        '''
818        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
819        '''
820
821        '''
822        self.healthy = healthy if healthy is not None else False
823        '''
824         True if the datasource is reachable and the credentials are valid.
825        '''
826        self.id = id if id is not None else ''
827        '''
828         Unique identifier of the Resource.
829        '''
830        self.name = name if name is not None else ''
831        '''
832         Unique human-readable name of the Resource.
833        '''
834        self.role_arn = role_arn if role_arn is not None else ''
835        '''
836
837        '''
838        self.role_external_id = role_external_id if role_external_id is not None else ''
839        '''
840
841        '''
842        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
843        '''
844
845        '''
846        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
847        '''
848         ID of the secret store containing credentials for this resource, if any.
849        '''
850        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
851        '''
852         Tags is a map of key, value pairs.
853        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
871    def to_dict(self):
872        return {
873            'access_key': self.access_key,
874            'bind_interface': self.bind_interface,
875            'egress_filter': self.egress_filter,
876            'healthcheck_region': self.healthcheck_region,
877            'healthy': self.healthy,
878            'id': self.id,
879            'name': self.name,
880            'role_arn': self.role_arn,
881            'role_external_id': self.role_external_id,
882            'secret_access_key': self.secret_access_key,
883            'secret_store_id': self.secret_store_id,
884            'tags': self.tags,
885        }
@classmethod
def from_dict(cls, d)
887    @classmethod
888    def from_dict(cls, d):
889        return cls(
890            access_key=d.get('access_key'),
891            bind_interface=d.get('bind_interface'),
892            egress_filter=d.get('egress_filter'),
893            healthcheck_region=d.get('healthcheck_region'),
894            healthy=d.get('healthy'),
895            id=d.get('id'),
896            name=d.get('name'),
897            role_arn=d.get('role_arn'),
898            role_external_id=d.get('role_external_id'),
899            secret_access_key=d.get('secret_access_key'),
900            secret_store_id=d.get('secret_store_id'),
901            tags=d.get('tags'),
902        )
class AWSStore:
905class AWSStore:
906    '''
907
908    '''
909    __slots__ = [
910        'id',
911        'name',
912        'region',
913        'tags',
914    ]
915
916    def __init__(
917        self,
918        id=None,
919        name=None,
920        region=None,
921        tags=None,
922    ):
923        self.id = id if id is not None else ''
924        '''
925         Unique identifier of the SecretStore.
926        '''
927        self.name = name if name is not None else ''
928        '''
929         Unique human-readable name of the SecretStore.
930        '''
931        self.region = region if region is not None else ''
932        '''
933
934        '''
935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
936        '''
937         Tags is a map of key, value pairs.
938        '''
939
940    def __repr__(self):
941        return '<sdm.AWSStore ' + \
942            'id: ' + repr(self.id) + ' ' +\
943            'name: ' + repr(self.name) + ' ' +\
944            'region: ' + repr(self.region) + ' ' +\
945            'tags: ' + repr(self.tags) + ' ' +\
946            '>'
947
948    def to_dict(self):
949        return {
950            'id': self.id,
951            'name': self.name,
952            'region': self.region,
953            'tags': self.tags,
954        }
955
956    @classmethod
957    def from_dict(cls, d):
958        return cls(
959            id=d.get('id'),
960            name=d.get('name'),
961            region=d.get('region'),
962            tags=d.get('tags'),
963        )
AWSStore(id=None, name=None, region=None, tags=None)
916    def __init__(
917        self,
918        id=None,
919        name=None,
920        region=None,
921        tags=None,
922    ):
923        self.id = id if id is not None else ''
924        '''
925         Unique identifier of the SecretStore.
926        '''
927        self.name = name if name is not None else ''
928        '''
929         Unique human-readable name of the SecretStore.
930        '''
931        self.region = region if region is not None else ''
932        '''
933
934        '''
935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
936        '''
937         Tags is a map of key, value pairs.
938        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
948    def to_dict(self):
949        return {
950            'id': self.id,
951            'name': self.name,
952            'region': self.region,
953            'tags': self.tags,
954        }
@classmethod
def from_dict(cls, d)
956    @classmethod
957    def from_dict(cls, d):
958        return cls(
959            id=d.get('id'),
960            name=d.get('name'),
961            region=d.get('region'),
962            tags=d.get('tags'),
963        )
class AccountAttachment:
 966class AccountAttachment:
 967    '''
 968     AccountAttachments assign an account to a role.
 969    '''
 970    __slots__ = [
 971        'account_id',
 972        'id',
 973        'role_id',
 974    ]
 975
 976    def __init__(
 977        self,
 978        account_id=None,
 979        id=None,
 980        role_id=None,
 981    ):
 982        self.account_id = account_id if account_id is not None else ''
 983        '''
 984         The id of the account of this AccountAttachment.
 985        '''
 986        self.id = id if id is not None else ''
 987        '''
 988         Unique identifier of the AccountAttachment.
 989        '''
 990        self.role_id = role_id if role_id is not None else ''
 991        '''
 992         The id of the attached role of this AccountAttachment.
 993        '''
 994
 995    def __repr__(self):
 996        return '<sdm.AccountAttachment ' + \
 997            'account_id: ' + repr(self.account_id) + ' ' +\
 998            'id: ' + repr(self.id) + ' ' +\
 999            'role_id: ' + repr(self.role_id) + ' ' +\
1000            '>'
1001
1002    def to_dict(self):
1003        return {
1004            'account_id': self.account_id,
1005            'id': self.id,
1006            'role_id': self.role_id,
1007        }
1008
1009    @classmethod
1010    def from_dict(cls, d):
1011        return cls(
1012            account_id=d.get('account_id'),
1013            id=d.get('id'),
1014            role_id=d.get('role_id'),
1015        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
976    def __init__(
977        self,
978        account_id=None,
979        id=None,
980        role_id=None,
981    ):
982        self.account_id = account_id if account_id is not None else ''
983        '''
984         The id of the account of this AccountAttachment.
985        '''
986        self.id = id if id is not None else ''
987        '''
988         Unique identifier of the AccountAttachment.
989        '''
990        self.role_id = role_id if role_id is not None else ''
991        '''
992         The id of the attached role of this AccountAttachment.
993        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1002    def to_dict(self):
1003        return {
1004            'account_id': self.account_id,
1005            'id': self.id,
1006            'role_id': self.role_id,
1007        }
@classmethod
def from_dict(cls, d)
1009    @classmethod
1010    def from_dict(cls, d):
1011        return cls(
1012            account_id=d.get('account_id'),
1013            id=d.get('id'),
1014            role_id=d.get('role_id'),
1015        )
class AccountAttachmentCreateResponse:
1018class AccountAttachmentCreateResponse:
1019    '''
1020     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1021    '''
1022    __slots__ = [
1023        'account_attachment',
1024        'meta',
1025        'rate_limit',
1026    ]
1027
1028    def __init__(
1029        self,
1030        account_attachment=None,
1031        meta=None,
1032        rate_limit=None,
1033    ):
1034        self.account_attachment = account_attachment if account_attachment is not None else None
1035        '''
1036         The created AccountAttachment.
1037        '''
1038        self.meta = meta if meta is not None else None
1039        '''
1040         Reserved for future use.
1041        '''
1042        self.rate_limit = rate_limit if rate_limit is not None else None
1043        '''
1044         Rate limit information.
1045        '''
1046
1047    def __repr__(self):
1048        return '<sdm.AccountAttachmentCreateResponse ' + \
1049            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1050            'meta: ' + repr(self.meta) + ' ' +\
1051            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1052            '>'
1053
1054    def to_dict(self):
1055        return {
1056            'account_attachment': self.account_attachment,
1057            'meta': self.meta,
1058            'rate_limit': self.rate_limit,
1059        }
1060
1061    @classmethod
1062    def from_dict(cls, d):
1063        return cls(
1064            account_attachment=d.get('account_attachment'),
1065            meta=d.get('meta'),
1066            rate_limit=d.get('rate_limit'),
1067        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1028    def __init__(
1029        self,
1030        account_attachment=None,
1031        meta=None,
1032        rate_limit=None,
1033    ):
1034        self.account_attachment = account_attachment if account_attachment is not None else None
1035        '''
1036         The created AccountAttachment.
1037        '''
1038        self.meta = meta if meta is not None else None
1039        '''
1040         Reserved for future use.
1041        '''
1042        self.rate_limit = rate_limit if rate_limit is not None else None
1043        '''
1044         Rate limit information.
1045        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1054    def to_dict(self):
1055        return {
1056            'account_attachment': self.account_attachment,
1057            'meta': self.meta,
1058            'rate_limit': self.rate_limit,
1059        }
@classmethod
def from_dict(cls, d)
1061    @classmethod
1062    def from_dict(cls, d):
1063        return cls(
1064            account_attachment=d.get('account_attachment'),
1065            meta=d.get('meta'),
1066            rate_limit=d.get('rate_limit'),
1067        )
class AccountAttachmentDeleteResponse:
1070class AccountAttachmentDeleteResponse:
1071    '''
1072     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1073    '''
1074    __slots__ = [
1075        'meta',
1076        'rate_limit',
1077    ]
1078
1079    def __init__(
1080        self,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.meta = meta if meta is not None else None
1085        '''
1086         Reserved for future use.
1087        '''
1088        self.rate_limit = rate_limit if rate_limit is not None else None
1089        '''
1090         Rate limit information.
1091        '''
1092
1093    def __repr__(self):
1094        return '<sdm.AccountAttachmentDeleteResponse ' + \
1095            'meta: ' + repr(self.meta) + ' ' +\
1096            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1097            '>'
1098
1099    def to_dict(self):
1100        return {
1101            'meta': self.meta,
1102            'rate_limit': self.rate_limit,
1103        }
1104
1105    @classmethod
1106    def from_dict(cls, d):
1107        return cls(
1108            meta=d.get('meta'),
1109            rate_limit=d.get('rate_limit'),
1110        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1079    def __init__(
1080        self,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.meta = meta if meta is not None else None
1085        '''
1086         Reserved for future use.
1087        '''
1088        self.rate_limit = rate_limit if rate_limit is not None else None
1089        '''
1090         Rate limit information.
1091        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1099    def to_dict(self):
1100        return {
1101            'meta': self.meta,
1102            'rate_limit': self.rate_limit,
1103        }
@classmethod
def from_dict(cls, d)
1105    @classmethod
1106    def from_dict(cls, d):
1107        return cls(
1108            meta=d.get('meta'),
1109            rate_limit=d.get('rate_limit'),
1110        )
class AccountAttachmentGetResponse:
1113class AccountAttachmentGetResponse:
1114    '''
1115     AccountAttachmentGetResponse returns a requested AccountAttachment.
1116    '''
1117    __slots__ = [
1118        'account_attachment',
1119        'meta',
1120        'rate_limit',
1121    ]
1122
1123    def __init__(
1124        self,
1125        account_attachment=None,
1126        meta=None,
1127        rate_limit=None,
1128    ):
1129        self.account_attachment = account_attachment if account_attachment is not None else None
1130        '''
1131         The requested AccountAttachment.
1132        '''
1133        self.meta = meta if meta is not None else None
1134        '''
1135         Reserved for future use.
1136        '''
1137        self.rate_limit = rate_limit if rate_limit is not None else None
1138        '''
1139         Rate limit information.
1140        '''
1141
1142    def __repr__(self):
1143        return '<sdm.AccountAttachmentGetResponse ' + \
1144            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1145            'meta: ' + repr(self.meta) + ' ' +\
1146            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1147            '>'
1148
1149    def to_dict(self):
1150        return {
1151            'account_attachment': self.account_attachment,
1152            'meta': self.meta,
1153            'rate_limit': self.rate_limit,
1154        }
1155
1156    @classmethod
1157    def from_dict(cls, d):
1158        return cls(
1159            account_attachment=d.get('account_attachment'),
1160            meta=d.get('meta'),
1161            rate_limit=d.get('rate_limit'),
1162        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1123    def __init__(
1124        self,
1125        account_attachment=None,
1126        meta=None,
1127        rate_limit=None,
1128    ):
1129        self.account_attachment = account_attachment if account_attachment is not None else None
1130        '''
1131         The requested AccountAttachment.
1132        '''
1133        self.meta = meta if meta is not None else None
1134        '''
1135         Reserved for future use.
1136        '''
1137        self.rate_limit = rate_limit if rate_limit is not None else None
1138        '''
1139         Rate limit information.
1140        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1149    def to_dict(self):
1150        return {
1151            'account_attachment': self.account_attachment,
1152            'meta': self.meta,
1153            'rate_limit': self.rate_limit,
1154        }
@classmethod
def from_dict(cls, d)
1156    @classmethod
1157    def from_dict(cls, d):
1158        return cls(
1159            account_attachment=d.get('account_attachment'),
1160            meta=d.get('meta'),
1161            rate_limit=d.get('rate_limit'),
1162        )
class AccountCreateResponse:
1165class AccountCreateResponse:
1166    '''
1167     AccountCreateResponse reports how the Accounts were created in the system.
1168    '''
1169    __slots__ = [
1170        'account',
1171        'meta',
1172        'rate_limit',
1173        'token',
1174    ]
1175
1176    def __init__(
1177        self,
1178        account=None,
1179        meta=None,
1180        rate_limit=None,
1181        token=None,
1182    ):
1183        self.account = account if account is not None else None
1184        '''
1185         The created Account.
1186        '''
1187        self.meta = meta if meta is not None else None
1188        '''
1189         Reserved for future use.
1190        '''
1191        self.rate_limit = rate_limit if rate_limit is not None else None
1192        '''
1193         Rate limit information.
1194        '''
1195        self.token = token if token is not None else ''
1196        '''
1197         The auth token generated for the Account. The Account will use this token to
1198         authenticate with the strongDM API.
1199        '''
1200
1201    def __repr__(self):
1202        return '<sdm.AccountCreateResponse ' + \
1203            'account: ' + repr(self.account) + ' ' +\
1204            'meta: ' + repr(self.meta) + ' ' +\
1205            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1206            'token: ' + repr(self.token) + ' ' +\
1207            '>'
1208
1209    def to_dict(self):
1210        return {
1211            'account': self.account,
1212            'meta': self.meta,
1213            'rate_limit': self.rate_limit,
1214            'token': self.token,
1215        }
1216
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            account=d.get('account'),
1221            meta=d.get('meta'),
1222            rate_limit=d.get('rate_limit'),
1223            token=d.get('token'),
1224        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1176    def __init__(
1177        self,
1178        account=None,
1179        meta=None,
1180        rate_limit=None,
1181        token=None,
1182    ):
1183        self.account = account if account is not None else None
1184        '''
1185         The created Account.
1186        '''
1187        self.meta = meta if meta is not None else None
1188        '''
1189         Reserved for future use.
1190        '''
1191        self.rate_limit = rate_limit if rate_limit is not None else None
1192        '''
1193         Rate limit information.
1194        '''
1195        self.token = token if token is not None else ''
1196        '''
1197         The auth token generated for the Account. The Account will use this token to
1198         authenticate with the strongDM API.
1199        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1209    def to_dict(self):
1210        return {
1211            'account': self.account,
1212            'meta': self.meta,
1213            'rate_limit': self.rate_limit,
1214            'token': self.token,
1215        }
@classmethod
def from_dict(cls, d)
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            account=d.get('account'),
1221            meta=d.get('meta'),
1222            rate_limit=d.get('rate_limit'),
1223            token=d.get('token'),
1224        )
class AccountDeleteResponse:
1227class AccountDeleteResponse:
1228    '''
1229     AccountDeleteResponse returns information about a Account that was deleted.
1230    '''
1231    __slots__ = [
1232        'meta',
1233        'rate_limit',
1234    ]
1235
1236    def __init__(
1237        self,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.meta = meta if meta is not None else None
1242        '''
1243         Reserved for future use.
1244        '''
1245        self.rate_limit = rate_limit if rate_limit is not None else None
1246        '''
1247         Rate limit information.
1248        '''
1249
1250    def __repr__(self):
1251        return '<sdm.AccountDeleteResponse ' + \
1252            'meta: ' + repr(self.meta) + ' ' +\
1253            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1254            '>'
1255
1256    def to_dict(self):
1257        return {
1258            'meta': self.meta,
1259            'rate_limit': self.rate_limit,
1260        }
1261
1262    @classmethod
1263    def from_dict(cls, d):
1264        return cls(
1265            meta=d.get('meta'),
1266            rate_limit=d.get('rate_limit'),
1267        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1236    def __init__(
1237        self,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.meta = meta if meta is not None else None
1242        '''
1243         Reserved for future use.
1244        '''
1245        self.rate_limit = rate_limit if rate_limit is not None else None
1246        '''
1247         Rate limit information.
1248        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1256    def to_dict(self):
1257        return {
1258            'meta': self.meta,
1259            'rate_limit': self.rate_limit,
1260        }
@classmethod
def from_dict(cls, d)
1262    @classmethod
1263    def from_dict(cls, d):
1264        return cls(
1265            meta=d.get('meta'),
1266            rate_limit=d.get('rate_limit'),
1267        )
class AccountGetResponse:
1270class AccountGetResponse:
1271    '''
1272     AccountGetResponse returns a requested Account.
1273    '''
1274    __slots__ = [
1275        'account',
1276        'meta',
1277        'rate_limit',
1278    ]
1279
1280    def __init__(
1281        self,
1282        account=None,
1283        meta=None,
1284        rate_limit=None,
1285    ):
1286        self.account = account if account is not None else None
1287        '''
1288         The requested Account.
1289        '''
1290        self.meta = meta if meta is not None else None
1291        '''
1292         Reserved for future use.
1293        '''
1294        self.rate_limit = rate_limit if rate_limit is not None else None
1295        '''
1296         Rate limit information.
1297        '''
1298
1299    def __repr__(self):
1300        return '<sdm.AccountGetResponse ' + \
1301            'account: ' + repr(self.account) + ' ' +\
1302            'meta: ' + repr(self.meta) + ' ' +\
1303            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1304            '>'
1305
1306    def to_dict(self):
1307        return {
1308            'account': self.account,
1309            'meta': self.meta,
1310            'rate_limit': self.rate_limit,
1311        }
1312
1313    @classmethod
1314    def from_dict(cls, d):
1315        return cls(
1316            account=d.get('account'),
1317            meta=d.get('meta'),
1318            rate_limit=d.get('rate_limit'),
1319        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1280    def __init__(
1281        self,
1282        account=None,
1283        meta=None,
1284        rate_limit=None,
1285    ):
1286        self.account = account if account is not None else None
1287        '''
1288         The requested Account.
1289        '''
1290        self.meta = meta if meta is not None else None
1291        '''
1292         Reserved for future use.
1293        '''
1294        self.rate_limit = rate_limit if rate_limit is not None else None
1295        '''
1296         Rate limit information.
1297        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1306    def to_dict(self):
1307        return {
1308            'account': self.account,
1309            'meta': self.meta,
1310            'rate_limit': self.rate_limit,
1311        }
@classmethod
def from_dict(cls, d)
1313    @classmethod
1314    def from_dict(cls, d):
1315        return cls(
1316            account=d.get('account'),
1317            meta=d.get('meta'),
1318            rate_limit=d.get('rate_limit'),
1319        )
class AccountGrant:
1322class AccountGrant:
1323    '''
1324     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1325    '''
1326    __slots__ = [
1327        'account_id',
1328        'id',
1329        'resource_id',
1330        'start_from',
1331        'valid_until',
1332    ]
1333
1334    def __init__(
1335        self,
1336        account_id=None,
1337        id=None,
1338        resource_id=None,
1339        start_from=None,
1340        valid_until=None,
1341    ):
1342        self.account_id = account_id if account_id is not None else ''
1343        '''
1344         The account id of this AccountGrant.
1345        '''
1346        self.id = id if id is not None else ''
1347        '''
1348         Unique identifier of the AccountGrant.
1349        '''
1350        self.resource_id = resource_id if resource_id is not None else ''
1351        '''
1352         The resource id of this AccountGrant.
1353        '''
1354        self.start_from = start_from if start_from is not None else None
1355        '''
1356         The timestamp when the resource will be granted. Optional. Both start_at
1357         and end_at must be defined together, or not defined at all.
1358        '''
1359        self.valid_until = valid_until if valid_until is not None else None
1360        '''
1361         The timestamp when the resource grant will expire. Optional. Both
1362         start_at and end_at must be defined together, or not defined at all.
1363        '''
1364
1365    def __repr__(self):
1366        return '<sdm.AccountGrant ' + \
1367            'account_id: ' + repr(self.account_id) + ' ' +\
1368            'id: ' + repr(self.id) + ' ' +\
1369            'resource_id: ' + repr(self.resource_id) + ' ' +\
1370            'start_from: ' + repr(self.start_from) + ' ' +\
1371            'valid_until: ' + repr(self.valid_until) + ' ' +\
1372            '>'
1373
1374    def to_dict(self):
1375        return {
1376            'account_id': self.account_id,
1377            'id': self.id,
1378            'resource_id': self.resource_id,
1379            'start_from': self.start_from,
1380            'valid_until': self.valid_until,
1381        }
1382
1383    @classmethod
1384    def from_dict(cls, d):
1385        return cls(
1386            account_id=d.get('account_id'),
1387            id=d.get('id'),
1388            resource_id=d.get('resource_id'),
1389            start_from=d.get('start_from'),
1390            valid_until=d.get('valid_until'),
1391        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1334    def __init__(
1335        self,
1336        account_id=None,
1337        id=None,
1338        resource_id=None,
1339        start_from=None,
1340        valid_until=None,
1341    ):
1342        self.account_id = account_id if account_id is not None else ''
1343        '''
1344         The account id of this AccountGrant.
1345        '''
1346        self.id = id if id is not None else ''
1347        '''
1348         Unique identifier of the AccountGrant.
1349        '''
1350        self.resource_id = resource_id if resource_id is not None else ''
1351        '''
1352         The resource id of this AccountGrant.
1353        '''
1354        self.start_from = start_from if start_from is not None else None
1355        '''
1356         The timestamp when the resource will be granted. Optional. Both start_at
1357         and end_at must be defined together, or not defined at all.
1358        '''
1359        self.valid_until = valid_until if valid_until is not None else None
1360        '''
1361         The timestamp when the resource grant will expire. Optional. Both
1362         start_at and end_at must be defined together, or not defined at all.
1363        '''
account_id

The account id of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource id of this AccountGrant.

start_from

The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all.

valid_until

The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.

def to_dict(self)
1374    def to_dict(self):
1375        return {
1376            'account_id': self.account_id,
1377            'id': self.id,
1378            'resource_id': self.resource_id,
1379            'start_from': self.start_from,
1380            'valid_until': self.valid_until,
1381        }
@classmethod
def from_dict(cls, d)
1383    @classmethod
1384    def from_dict(cls, d):
1385        return cls(
1386            account_id=d.get('account_id'),
1387            id=d.get('id'),
1388            resource_id=d.get('resource_id'),
1389            start_from=d.get('start_from'),
1390            valid_until=d.get('valid_until'),
1391        )
class AccountGrantCreateResponse:
1394class AccountGrantCreateResponse:
1395    '''
1396     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1397    '''
1398    __slots__ = [
1399        'account_grant',
1400        'meta',
1401        'rate_limit',
1402    ]
1403
1404    def __init__(
1405        self,
1406        account_grant=None,
1407        meta=None,
1408        rate_limit=None,
1409    ):
1410        self.account_grant = account_grant if account_grant is not None else None
1411        '''
1412         The created AccountGrant.
1413        '''
1414        self.meta = meta if meta is not None else None
1415        '''
1416         Reserved for future use.
1417        '''
1418        self.rate_limit = rate_limit if rate_limit is not None else None
1419        '''
1420         Rate limit information.
1421        '''
1422
1423    def __repr__(self):
1424        return '<sdm.AccountGrantCreateResponse ' + \
1425            'account_grant: ' + repr(self.account_grant) + ' ' +\
1426            'meta: ' + repr(self.meta) + ' ' +\
1427            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1428            '>'
1429
1430    def to_dict(self):
1431        return {
1432            'account_grant': self.account_grant,
1433            'meta': self.meta,
1434            'rate_limit': self.rate_limit,
1435        }
1436
1437    @classmethod
1438    def from_dict(cls, d):
1439        return cls(
1440            account_grant=d.get('account_grant'),
1441            meta=d.get('meta'),
1442            rate_limit=d.get('rate_limit'),
1443        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1404    def __init__(
1405        self,
1406        account_grant=None,
1407        meta=None,
1408        rate_limit=None,
1409    ):
1410        self.account_grant = account_grant if account_grant is not None else None
1411        '''
1412         The created AccountGrant.
1413        '''
1414        self.meta = meta if meta is not None else None
1415        '''
1416         Reserved for future use.
1417        '''
1418        self.rate_limit = rate_limit if rate_limit is not None else None
1419        '''
1420         Rate limit information.
1421        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1430    def to_dict(self):
1431        return {
1432            'account_grant': self.account_grant,
1433            'meta': self.meta,
1434            'rate_limit': self.rate_limit,
1435        }
@classmethod
def from_dict(cls, d)
1437    @classmethod
1438    def from_dict(cls, d):
1439        return cls(
1440            account_grant=d.get('account_grant'),
1441            meta=d.get('meta'),
1442            rate_limit=d.get('rate_limit'),
1443        )
class AccountGrantDeleteResponse:
1446class AccountGrantDeleteResponse:
1447    '''
1448     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1449    '''
1450    __slots__ = [
1451        'meta',
1452        'rate_limit',
1453    ]
1454
1455    def __init__(
1456        self,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGrantDeleteResponse ' + \
1471            'meta: ' + repr(self.meta) + ' ' +\
1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1473            '>'
1474
1475    def to_dict(self):
1476        return {
1477            'meta': self.meta,
1478            'rate_limit': self.rate_limit,
1479        }
1480
1481    @classmethod
1482    def from_dict(cls, d):
1483        return cls(
1484            meta=d.get('meta'),
1485            rate_limit=d.get('rate_limit'),
1486        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1455    def __init__(
1456        self,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1475    def to_dict(self):
1476        return {
1477            'meta': self.meta,
1478            'rate_limit': self.rate_limit,
1479        }
@classmethod
def from_dict(cls, d)
1481    @classmethod
1482    def from_dict(cls, d):
1483        return cls(
1484            meta=d.get('meta'),
1485            rate_limit=d.get('rate_limit'),
1486        )
class AccountGrantGetResponse:
1489class AccountGrantGetResponse:
1490    '''
1491     AccountGrantGetResponse returns a requested AccountGrant.
1492    '''
1493    __slots__ = [
1494        'account_grant',
1495        'meta',
1496        'rate_limit',
1497    ]
1498
1499    def __init__(
1500        self,
1501        account_grant=None,
1502        meta=None,
1503        rate_limit=None,
1504    ):
1505        self.account_grant = account_grant if account_grant is not None else None
1506        '''
1507         The requested AccountGrant.
1508        '''
1509        self.meta = meta if meta is not None else None
1510        '''
1511         Reserved for future use.
1512        '''
1513        self.rate_limit = rate_limit if rate_limit is not None else None
1514        '''
1515         Rate limit information.
1516        '''
1517
1518    def __repr__(self):
1519        return '<sdm.AccountGrantGetResponse ' + \
1520            'account_grant: ' + repr(self.account_grant) + ' ' +\
1521            'meta: ' + repr(self.meta) + ' ' +\
1522            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1523            '>'
1524
1525    def to_dict(self):
1526        return {
1527            'account_grant': self.account_grant,
1528            'meta': self.meta,
1529            'rate_limit': self.rate_limit,
1530        }
1531
1532    @classmethod
1533    def from_dict(cls, d):
1534        return cls(
1535            account_grant=d.get('account_grant'),
1536            meta=d.get('meta'),
1537            rate_limit=d.get('rate_limit'),
1538        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1499    def __init__(
1500        self,
1501        account_grant=None,
1502        meta=None,
1503        rate_limit=None,
1504    ):
1505        self.account_grant = account_grant if account_grant is not None else None
1506        '''
1507         The requested AccountGrant.
1508        '''
1509        self.meta = meta if meta is not None else None
1510        '''
1511         Reserved for future use.
1512        '''
1513        self.rate_limit = rate_limit if rate_limit is not None else None
1514        '''
1515         Rate limit information.
1516        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1525    def to_dict(self):
1526        return {
1527            'account_grant': self.account_grant,
1528            'meta': self.meta,
1529            'rate_limit': self.rate_limit,
1530        }
@classmethod
def from_dict(cls, d)
1532    @classmethod
1533    def from_dict(cls, d):
1534        return cls(
1535            account_grant=d.get('account_grant'),
1536            meta=d.get('meta'),
1537            rate_limit=d.get('rate_limit'),
1538        )
class AccountUpdateResponse:
1541class AccountUpdateResponse:
1542    '''
1543     AccountUpdateResponse returns the fields of a Account after it has been updated by
1544     a AccountUpdateRequest.
1545    '''
1546    __slots__ = [
1547        'account',
1548        'meta',
1549        'rate_limit',
1550    ]
1551
1552    def __init__(
1553        self,
1554        account=None,
1555        meta=None,
1556        rate_limit=None,
1557    ):
1558        self.account = account if account is not None else None
1559        '''
1560         The updated Account.
1561        '''
1562        self.meta = meta if meta is not None else None
1563        '''
1564         Reserved for future use.
1565        '''
1566        self.rate_limit = rate_limit if rate_limit is not None else None
1567        '''
1568         Rate limit information.
1569        '''
1570
1571    def __repr__(self):
1572        return '<sdm.AccountUpdateResponse ' + \
1573            'account: ' + repr(self.account) + ' ' +\
1574            'meta: ' + repr(self.meta) + ' ' +\
1575            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1576            '>'
1577
1578    def to_dict(self):
1579        return {
1580            'account': self.account,
1581            'meta': self.meta,
1582            'rate_limit': self.rate_limit,
1583        }
1584
1585    @classmethod
1586    def from_dict(cls, d):
1587        return cls(
1588            account=d.get('account'),
1589            meta=d.get('meta'),
1590            rate_limit=d.get('rate_limit'),
1591        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1552    def __init__(
1553        self,
1554        account=None,
1555        meta=None,
1556        rate_limit=None,
1557    ):
1558        self.account = account if account is not None else None
1559        '''
1560         The updated Account.
1561        '''
1562        self.meta = meta if meta is not None else None
1563        '''
1564         Reserved for future use.
1565        '''
1566        self.rate_limit = rate_limit if rate_limit is not None else None
1567        '''
1568         Rate limit information.
1569        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1578    def to_dict(self):
1579        return {
1580            'account': self.account,
1581            'meta': self.meta,
1582            'rate_limit': self.rate_limit,
1583        }
@classmethod
def from_dict(cls, d)
1585    @classmethod
1586    def from_dict(cls, d):
1587        return cls(
1588            account=d.get('account'),
1589            meta=d.get('meta'),
1590            rate_limit=d.get('rate_limit'),
1591        )
class AmazonEKS:
1594class AmazonEKS:
1595    '''
1596
1597    '''
1598    __slots__ = [
1599        'access_key',
1600        'bind_interface',
1601        'certificate_authority',
1602        'cluster_name',
1603        'egress_filter',
1604        'endpoint',
1605        'healthcheck_namespace',
1606        'healthy',
1607        'id',
1608        'name',
1609        'region',
1610        'remote_identity_group_id',
1611        'remote_identity_healthcheck_username',
1612        'role_arn',
1613        'role_external_id',
1614        'secret_access_key',
1615        'secret_store_id',
1616        'tags',
1617    ]
1618
1619    def __init__(
1620        self,
1621        access_key=None,
1622        bind_interface=None,
1623        certificate_authority=None,
1624        cluster_name=None,
1625        egress_filter=None,
1626        endpoint=None,
1627        healthcheck_namespace=None,
1628        healthy=None,
1629        id=None,
1630        name=None,
1631        region=None,
1632        remote_identity_group_id=None,
1633        remote_identity_healthcheck_username=None,
1634        role_arn=None,
1635        role_external_id=None,
1636        secret_access_key=None,
1637        secret_store_id=None,
1638        tags=None,
1639    ):
1640        self.access_key = access_key if access_key is not None else ''
1641        '''
1642
1643        '''
1644        self.bind_interface = bind_interface if bind_interface is not None else ''
1645        '''
1646         Bind interface
1647        '''
1648        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1649        '''
1650
1651        '''
1652        self.cluster_name = cluster_name if cluster_name is not None else ''
1653        '''
1654
1655        '''
1656        self.egress_filter = egress_filter if egress_filter is not None else ''
1657        '''
1658         A filter applied to the routing logic to pin datasource to nodes.
1659        '''
1660        self.endpoint = endpoint if endpoint is not None else ''
1661        '''
1662
1663        '''
1664        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1665        '''
1666         The path used to check the health of your connection.  Defaults to `default`.
1667        '''
1668        self.healthy = healthy if healthy is not None else False
1669        '''
1670         True if the datasource is reachable and the credentials are valid.
1671        '''
1672        self.id = id if id is not None else ''
1673        '''
1674         Unique identifier of the Resource.
1675        '''
1676        self.name = name if name is not None else ''
1677        '''
1678         Unique human-readable name of the Resource.
1679        '''
1680        self.region = region if region is not None else ''
1681        '''
1682
1683        '''
1684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1685        '''
1686
1687        '''
1688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1689        '''
1690
1691        '''
1692        self.role_arn = role_arn if role_arn is not None else ''
1693        '''
1694
1695        '''
1696        self.role_external_id = role_external_id if role_external_id is not None else ''
1697        '''
1698
1699        '''
1700        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1701        '''
1702
1703        '''
1704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1705        '''
1706         ID of the secret store containing credentials for this resource, if any.
1707        '''
1708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1709        '''
1710         Tags is a map of key, value pairs.
1711        '''
1712
1713    def __repr__(self):
1714        return '<sdm.AmazonEKS ' + \
1715            'access_key: ' + repr(self.access_key) + ' ' +\
1716            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1717            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1718            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1719            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1720            'endpoint: ' + repr(self.endpoint) + ' ' +\
1721            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1722            'healthy: ' + repr(self.healthy) + ' ' +\
1723            'id: ' + repr(self.id) + ' ' +\
1724            'name: ' + repr(self.name) + ' ' +\
1725            'region: ' + repr(self.region) + ' ' +\
1726            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1727            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1728            'role_arn: ' + repr(self.role_arn) + ' ' +\
1729            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1730            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1731            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1732            'tags: ' + repr(self.tags) + ' ' +\
1733            '>'
1734
1735    def to_dict(self):
1736        return {
1737            'access_key': self.access_key,
1738            'bind_interface': self.bind_interface,
1739            'certificate_authority': self.certificate_authority,
1740            'cluster_name': self.cluster_name,
1741            'egress_filter': self.egress_filter,
1742            'endpoint': self.endpoint,
1743            'healthcheck_namespace': self.healthcheck_namespace,
1744            'healthy': self.healthy,
1745            'id': self.id,
1746            'name': self.name,
1747            'region': self.region,
1748            'remote_identity_group_id': self.remote_identity_group_id,
1749            'remote_identity_healthcheck_username':
1750            self.remote_identity_healthcheck_username,
1751            'role_arn': self.role_arn,
1752            'role_external_id': self.role_external_id,
1753            'secret_access_key': self.secret_access_key,
1754            'secret_store_id': self.secret_store_id,
1755            'tags': self.tags,
1756        }
1757
1758    @classmethod
1759    def from_dict(cls, d):
1760        return cls(
1761            access_key=d.get('access_key'),
1762            bind_interface=d.get('bind_interface'),
1763            certificate_authority=d.get('certificate_authority'),
1764            cluster_name=d.get('cluster_name'),
1765            egress_filter=d.get('egress_filter'),
1766            endpoint=d.get('endpoint'),
1767            healthcheck_namespace=d.get('healthcheck_namespace'),
1768            healthy=d.get('healthy'),
1769            id=d.get('id'),
1770            name=d.get('name'),
1771            region=d.get('region'),
1772            remote_identity_group_id=d.get('remote_identity_group_id'),
1773            remote_identity_healthcheck_username=d.get(
1774                'remote_identity_healthcheck_username'),
1775            role_arn=d.get('role_arn'),
1776            role_external_id=d.get('role_external_id'),
1777            secret_access_key=d.get('secret_access_key'),
1778            secret_store_id=d.get('secret_store_id'),
1779            tags=d.get('tags'),
1780        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1619    def __init__(
1620        self,
1621        access_key=None,
1622        bind_interface=None,
1623        certificate_authority=None,
1624        cluster_name=None,
1625        egress_filter=None,
1626        endpoint=None,
1627        healthcheck_namespace=None,
1628        healthy=None,
1629        id=None,
1630        name=None,
1631        region=None,
1632        remote_identity_group_id=None,
1633        remote_identity_healthcheck_username=None,
1634        role_arn=None,
1635        role_external_id=None,
1636        secret_access_key=None,
1637        secret_store_id=None,
1638        tags=None,
1639    ):
1640        self.access_key = access_key if access_key is not None else ''
1641        '''
1642
1643        '''
1644        self.bind_interface = bind_interface if bind_interface is not None else ''
1645        '''
1646         Bind interface
1647        '''
1648        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1649        '''
1650
1651        '''
1652        self.cluster_name = cluster_name if cluster_name is not None else ''
1653        '''
1654
1655        '''
1656        self.egress_filter = egress_filter if egress_filter is not None else ''
1657        '''
1658         A filter applied to the routing logic to pin datasource to nodes.
1659        '''
1660        self.endpoint = endpoint if endpoint is not None else ''
1661        '''
1662
1663        '''
1664        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1665        '''
1666         The path used to check the health of your connection.  Defaults to `default`.
1667        '''
1668        self.healthy = healthy if healthy is not None else False
1669        '''
1670         True if the datasource is reachable and the credentials are valid.
1671        '''
1672        self.id = id if id is not None else ''
1673        '''
1674         Unique identifier of the Resource.
1675        '''
1676        self.name = name if name is not None else ''
1677        '''
1678         Unique human-readable name of the Resource.
1679        '''
1680        self.region = region if region is not None else ''
1681        '''
1682
1683        '''
1684        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1685        '''
1686
1687        '''
1688        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1689        '''
1690
1691        '''
1692        self.role_arn = role_arn if role_arn is not None else ''
1693        '''
1694
1695        '''
1696        self.role_external_id = role_external_id if role_external_id is not None else ''
1697        '''
1698
1699        '''
1700        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1701        '''
1702
1703        '''
1704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1705        '''
1706         ID of the secret store containing credentials for this resource, if any.
1707        '''
1708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1709        '''
1710         Tags is a map of key, value pairs.
1711        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1735    def to_dict(self):
1736        return {
1737            'access_key': self.access_key,
1738            'bind_interface': self.bind_interface,
1739            'certificate_authority': self.certificate_authority,
1740            'cluster_name': self.cluster_name,
1741            'egress_filter': self.egress_filter,
1742            'endpoint': self.endpoint,
1743            'healthcheck_namespace': self.healthcheck_namespace,
1744            'healthy': self.healthy,
1745            'id': self.id,
1746            'name': self.name,
1747            'region': self.region,
1748            'remote_identity_group_id': self.remote_identity_group_id,
1749            'remote_identity_healthcheck_username':
1750            self.remote_identity_healthcheck_username,
1751            'role_arn': self.role_arn,
1752            'role_external_id': self.role_external_id,
1753            'secret_access_key': self.secret_access_key,
1754            'secret_store_id': self.secret_store_id,
1755            'tags': self.tags,
1756        }
@classmethod
def from_dict(cls, d)
1758    @classmethod
1759    def from_dict(cls, d):
1760        return cls(
1761            access_key=d.get('access_key'),
1762            bind_interface=d.get('bind_interface'),
1763            certificate_authority=d.get('certificate_authority'),
1764            cluster_name=d.get('cluster_name'),
1765            egress_filter=d.get('egress_filter'),
1766            endpoint=d.get('endpoint'),
1767            healthcheck_namespace=d.get('healthcheck_namespace'),
1768            healthy=d.get('healthy'),
1769            id=d.get('id'),
1770            name=d.get('name'),
1771            region=d.get('region'),
1772            remote_identity_group_id=d.get('remote_identity_group_id'),
1773            remote_identity_healthcheck_username=d.get(
1774                'remote_identity_healthcheck_username'),
1775            role_arn=d.get('role_arn'),
1776            role_external_id=d.get('role_external_id'),
1777            secret_access_key=d.get('secret_access_key'),
1778            secret_store_id=d.get('secret_store_id'),
1779            tags=d.get('tags'),
1780        )
class AmazonEKSUserImpersonation:
1783class AmazonEKSUserImpersonation:
1784    '''
1785
1786    '''
1787    __slots__ = [
1788        'access_key',
1789        'bind_interface',
1790        'certificate_authority',
1791        'cluster_name',
1792        'egress_filter',
1793        'endpoint',
1794        'healthcheck_namespace',
1795        'healthy',
1796        'id',
1797        'name',
1798        'region',
1799        'role_arn',
1800        'role_external_id',
1801        'secret_access_key',
1802        'secret_store_id',
1803        'tags',
1804    ]
1805
1806    def __init__(
1807        self,
1808        access_key=None,
1809        bind_interface=None,
1810        certificate_authority=None,
1811        cluster_name=None,
1812        egress_filter=None,
1813        endpoint=None,
1814        healthcheck_namespace=None,
1815        healthy=None,
1816        id=None,
1817        name=None,
1818        region=None,
1819        role_arn=None,
1820        role_external_id=None,
1821        secret_access_key=None,
1822        secret_store_id=None,
1823        tags=None,
1824    ):
1825        self.access_key = access_key if access_key is not None else ''
1826        '''
1827
1828        '''
1829        self.bind_interface = bind_interface if bind_interface is not None else ''
1830        '''
1831         Bind interface
1832        '''
1833        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1834        '''
1835
1836        '''
1837        self.cluster_name = cluster_name if cluster_name is not None else ''
1838        '''
1839
1840        '''
1841        self.egress_filter = egress_filter if egress_filter is not None else ''
1842        '''
1843         A filter applied to the routing logic to pin datasource to nodes.
1844        '''
1845        self.endpoint = endpoint if endpoint is not None else ''
1846        '''
1847
1848        '''
1849        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1850        '''
1851         The path used to check the health of your connection.  Defaults to `default`.
1852        '''
1853        self.healthy = healthy if healthy is not None else False
1854        '''
1855         True if the datasource is reachable and the credentials are valid.
1856        '''
1857        self.id = id if id is not None else ''
1858        '''
1859         Unique identifier of the Resource.
1860        '''
1861        self.name = name if name is not None else ''
1862        '''
1863         Unique human-readable name of the Resource.
1864        '''
1865        self.region = region if region is not None else ''
1866        '''
1867
1868        '''
1869        self.role_arn = role_arn if role_arn is not None else ''
1870        '''
1871
1872        '''
1873        self.role_external_id = role_external_id if role_external_id is not None else ''
1874        '''
1875
1876        '''
1877        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1878        '''
1879
1880        '''
1881        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1882        '''
1883         ID of the secret store containing credentials for this resource, if any.
1884        '''
1885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1886        '''
1887         Tags is a map of key, value pairs.
1888        '''
1889
1890    def __repr__(self):
1891        return '<sdm.AmazonEKSUserImpersonation ' + \
1892            'access_key: ' + repr(self.access_key) + ' ' +\
1893            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1894            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1895            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1896            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1897            'endpoint: ' + repr(self.endpoint) + ' ' +\
1898            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1899            'healthy: ' + repr(self.healthy) + ' ' +\
1900            'id: ' + repr(self.id) + ' ' +\
1901            'name: ' + repr(self.name) + ' ' +\
1902            'region: ' + repr(self.region) + ' ' +\
1903            'role_arn: ' + repr(self.role_arn) + ' ' +\
1904            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1905            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1906            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1907            'tags: ' + repr(self.tags) + ' ' +\
1908            '>'
1909
1910    def to_dict(self):
1911        return {
1912            'access_key': self.access_key,
1913            'bind_interface': self.bind_interface,
1914            'certificate_authority': self.certificate_authority,
1915            'cluster_name': self.cluster_name,
1916            'egress_filter': self.egress_filter,
1917            'endpoint': self.endpoint,
1918            'healthcheck_namespace': self.healthcheck_namespace,
1919            'healthy': self.healthy,
1920            'id': self.id,
1921            'name': self.name,
1922            'region': self.region,
1923            'role_arn': self.role_arn,
1924            'role_external_id': self.role_external_id,
1925            'secret_access_key': self.secret_access_key,
1926            'secret_store_id': self.secret_store_id,
1927            'tags': self.tags,
1928        }
1929
1930    @classmethod
1931    def from_dict(cls, d):
1932        return cls(
1933            access_key=d.get('access_key'),
1934            bind_interface=d.get('bind_interface'),
1935            certificate_authority=d.get('certificate_authority'),
1936            cluster_name=d.get('cluster_name'),
1937            egress_filter=d.get('egress_filter'),
1938            endpoint=d.get('endpoint'),
1939            healthcheck_namespace=d.get('healthcheck_namespace'),
1940            healthy=d.get('healthy'),
1941            id=d.get('id'),
1942            name=d.get('name'),
1943            region=d.get('region'),
1944            role_arn=d.get('role_arn'),
1945            role_external_id=d.get('role_external_id'),
1946            secret_access_key=d.get('secret_access_key'),
1947            secret_store_id=d.get('secret_store_id'),
1948            tags=d.get('tags'),
1949        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1806    def __init__(
1807        self,
1808        access_key=None,
1809        bind_interface=None,
1810        certificate_authority=None,
1811        cluster_name=None,
1812        egress_filter=None,
1813        endpoint=None,
1814        healthcheck_namespace=None,
1815        healthy=None,
1816        id=None,
1817        name=None,
1818        region=None,
1819        role_arn=None,
1820        role_external_id=None,
1821        secret_access_key=None,
1822        secret_store_id=None,
1823        tags=None,
1824    ):
1825        self.access_key = access_key if access_key is not None else ''
1826        '''
1827
1828        '''
1829        self.bind_interface = bind_interface if bind_interface is not None else ''
1830        '''
1831         Bind interface
1832        '''
1833        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1834        '''
1835
1836        '''
1837        self.cluster_name = cluster_name if cluster_name is not None else ''
1838        '''
1839
1840        '''
1841        self.egress_filter = egress_filter if egress_filter is not None else ''
1842        '''
1843         A filter applied to the routing logic to pin datasource to nodes.
1844        '''
1845        self.endpoint = endpoint if endpoint is not None else ''
1846        '''
1847
1848        '''
1849        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1850        '''
1851         The path used to check the health of your connection.  Defaults to `default`.
1852        '''
1853        self.healthy = healthy if healthy is not None else False
1854        '''
1855         True if the datasource is reachable and the credentials are valid.
1856        '''
1857        self.id = id if id is not None else ''
1858        '''
1859         Unique identifier of the Resource.
1860        '''
1861        self.name = name if name is not None else ''
1862        '''
1863         Unique human-readable name of the Resource.
1864        '''
1865        self.region = region if region is not None else ''
1866        '''
1867
1868        '''
1869        self.role_arn = role_arn if role_arn is not None else ''
1870        '''
1871
1872        '''
1873        self.role_external_id = role_external_id if role_external_id is not None else ''
1874        '''
1875
1876        '''
1877        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1878        '''
1879
1880        '''
1881        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1882        '''
1883         ID of the secret store containing credentials for this resource, if any.
1884        '''
1885        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1886        '''
1887         Tags is a map of key, value pairs.
1888        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1910    def to_dict(self):
1911        return {
1912            'access_key': self.access_key,
1913            'bind_interface': self.bind_interface,
1914            'certificate_authority': self.certificate_authority,
1915            'cluster_name': self.cluster_name,
1916            'egress_filter': self.egress_filter,
1917            'endpoint': self.endpoint,
1918            'healthcheck_namespace': self.healthcheck_namespace,
1919            'healthy': self.healthy,
1920            'id': self.id,
1921            'name': self.name,
1922            'region': self.region,
1923            'role_arn': self.role_arn,
1924            'role_external_id': self.role_external_id,
1925            'secret_access_key': self.secret_access_key,
1926            'secret_store_id': self.secret_store_id,
1927            'tags': self.tags,
1928        }
@classmethod
def from_dict(cls, d)
1930    @classmethod
1931    def from_dict(cls, d):
1932        return cls(
1933            access_key=d.get('access_key'),
1934            bind_interface=d.get('bind_interface'),
1935            certificate_authority=d.get('certificate_authority'),
1936            cluster_name=d.get('cluster_name'),
1937            egress_filter=d.get('egress_filter'),
1938            endpoint=d.get('endpoint'),
1939            healthcheck_namespace=d.get('healthcheck_namespace'),
1940            healthy=d.get('healthy'),
1941            id=d.get('id'),
1942            name=d.get('name'),
1943            region=d.get('region'),
1944            role_arn=d.get('role_arn'),
1945            role_external_id=d.get('role_external_id'),
1946            secret_access_key=d.get('secret_access_key'),
1947            secret_store_id=d.get('secret_store_id'),
1948            tags=d.get('tags'),
1949        )
class AmazonES:
1952class AmazonES:
1953    '''
1954
1955    '''
1956    __slots__ = [
1957        'access_key',
1958        'bind_interface',
1959        'egress_filter',
1960        'endpoint',
1961        'healthy',
1962        'id',
1963        'name',
1964        'port_override',
1965        'region',
1966        'role_arn',
1967        'role_external_id',
1968        'secret_access_key',
1969        'secret_store_id',
1970        'tags',
1971    ]
1972
1973    def __init__(
1974        self,
1975        access_key=None,
1976        bind_interface=None,
1977        egress_filter=None,
1978        endpoint=None,
1979        healthy=None,
1980        id=None,
1981        name=None,
1982        port_override=None,
1983        region=None,
1984        role_arn=None,
1985        role_external_id=None,
1986        secret_access_key=None,
1987        secret_store_id=None,
1988        tags=None,
1989    ):
1990        self.access_key = access_key if access_key is not None else ''
1991        '''
1992
1993        '''
1994        self.bind_interface = bind_interface if bind_interface is not None else ''
1995        '''
1996         Bind interface
1997        '''
1998        self.egress_filter = egress_filter if egress_filter is not None else ''
1999        '''
2000         A filter applied to the routing logic to pin datasource to nodes.
2001        '''
2002        self.endpoint = endpoint if endpoint is not None else ''
2003        '''
2004
2005        '''
2006        self.healthy = healthy if healthy is not None else False
2007        '''
2008         True if the datasource is reachable and the credentials are valid.
2009        '''
2010        self.id = id if id is not None else ''
2011        '''
2012         Unique identifier of the Resource.
2013        '''
2014        self.name = name if name is not None else ''
2015        '''
2016         Unique human-readable name of the Resource.
2017        '''
2018        self.port_override = port_override if port_override is not None else 0
2019        '''
2020
2021        '''
2022        self.region = region if region is not None else ''
2023        '''
2024
2025        '''
2026        self.role_arn = role_arn if role_arn is not None else ''
2027        '''
2028
2029        '''
2030        self.role_external_id = role_external_id if role_external_id is not None else ''
2031        '''
2032
2033        '''
2034        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2035        '''
2036
2037        '''
2038        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2039        '''
2040         ID of the secret store containing credentials for this resource, if any.
2041        '''
2042        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2043        '''
2044         Tags is a map of key, value pairs.
2045        '''
2046
2047    def __repr__(self):
2048        return '<sdm.AmazonES ' + \
2049            'access_key: ' + repr(self.access_key) + ' ' +\
2050            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2051            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2052            'endpoint: ' + repr(self.endpoint) + ' ' +\
2053            'healthy: ' + repr(self.healthy) + ' ' +\
2054            'id: ' + repr(self.id) + ' ' +\
2055            'name: ' + repr(self.name) + ' ' +\
2056            'port_override: ' + repr(self.port_override) + ' ' +\
2057            'region: ' + repr(self.region) + ' ' +\
2058            'role_arn: ' + repr(self.role_arn) + ' ' +\
2059            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2060            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2061            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2062            'tags: ' + repr(self.tags) + ' ' +\
2063            '>'
2064
2065    def to_dict(self):
2066        return {
2067            'access_key': self.access_key,
2068            'bind_interface': self.bind_interface,
2069            'egress_filter': self.egress_filter,
2070            'endpoint': self.endpoint,
2071            'healthy': self.healthy,
2072            'id': self.id,
2073            'name': self.name,
2074            'port_override': self.port_override,
2075            'region': self.region,
2076            'role_arn': self.role_arn,
2077            'role_external_id': self.role_external_id,
2078            'secret_access_key': self.secret_access_key,
2079            'secret_store_id': self.secret_store_id,
2080            'tags': self.tags,
2081        }
2082
2083    @classmethod
2084    def from_dict(cls, d):
2085        return cls(
2086            access_key=d.get('access_key'),
2087            bind_interface=d.get('bind_interface'),
2088            egress_filter=d.get('egress_filter'),
2089            endpoint=d.get('endpoint'),
2090            healthy=d.get('healthy'),
2091            id=d.get('id'),
2092            name=d.get('name'),
2093            port_override=d.get('port_override'),
2094            region=d.get('region'),
2095            role_arn=d.get('role_arn'),
2096            role_external_id=d.get('role_external_id'),
2097            secret_access_key=d.get('secret_access_key'),
2098            secret_store_id=d.get('secret_store_id'),
2099            tags=d.get('tags'),
2100        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1973    def __init__(
1974        self,
1975        access_key=None,
1976        bind_interface=None,
1977        egress_filter=None,
1978        endpoint=None,
1979        healthy=None,
1980        id=None,
1981        name=None,
1982        port_override=None,
1983        region=None,
1984        role_arn=None,
1985        role_external_id=None,
1986        secret_access_key=None,
1987        secret_store_id=None,
1988        tags=None,
1989    ):
1990        self.access_key = access_key if access_key is not None else ''
1991        '''
1992
1993        '''
1994        self.bind_interface = bind_interface if bind_interface is not None else ''
1995        '''
1996         Bind interface
1997        '''
1998        self.egress_filter = egress_filter if egress_filter is not None else ''
1999        '''
2000         A filter applied to the routing logic to pin datasource to nodes.
2001        '''
2002        self.endpoint = endpoint if endpoint is not None else ''
2003        '''
2004
2005        '''
2006        self.healthy = healthy if healthy is not None else False
2007        '''
2008         True if the datasource is reachable and the credentials are valid.
2009        '''
2010        self.id = id if id is not None else ''
2011        '''
2012         Unique identifier of the Resource.
2013        '''
2014        self.name = name if name is not None else ''
2015        '''
2016         Unique human-readable name of the Resource.
2017        '''
2018        self.port_override = port_override if port_override is not None else 0
2019        '''
2020
2021        '''
2022        self.region = region if region is not None else ''
2023        '''
2024
2025        '''
2026        self.role_arn = role_arn if role_arn is not None else ''
2027        '''
2028
2029        '''
2030        self.role_external_id = role_external_id if role_external_id is not None else ''
2031        '''
2032
2033        '''
2034        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2035        '''
2036
2037        '''
2038        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2039        '''
2040         ID of the secret store containing credentials for this resource, if any.
2041        '''
2042        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2043        '''
2044         Tags is a map of key, value pairs.
2045        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2065    def to_dict(self):
2066        return {
2067            'access_key': self.access_key,
2068            'bind_interface': self.bind_interface,
2069            'egress_filter': self.egress_filter,
2070            'endpoint': self.endpoint,
2071            'healthy': self.healthy,
2072            'id': self.id,
2073            'name': self.name,
2074            'port_override': self.port_override,
2075            'region': self.region,
2076            'role_arn': self.role_arn,
2077            'role_external_id': self.role_external_id,
2078            'secret_access_key': self.secret_access_key,
2079            'secret_store_id': self.secret_store_id,
2080            'tags': self.tags,
2081        }
@classmethod
def from_dict(cls, d)
2083    @classmethod
2084    def from_dict(cls, d):
2085        return cls(
2086            access_key=d.get('access_key'),
2087            bind_interface=d.get('bind_interface'),
2088            egress_filter=d.get('egress_filter'),
2089            endpoint=d.get('endpoint'),
2090            healthy=d.get('healthy'),
2091            id=d.get('id'),
2092            name=d.get('name'),
2093            port_override=d.get('port_override'),
2094            region=d.get('region'),
2095            role_arn=d.get('role_arn'),
2096            role_external_id=d.get('role_external_id'),
2097            secret_access_key=d.get('secret_access_key'),
2098            secret_store_id=d.get('secret_store_id'),
2099            tags=d.get('tags'),
2100        )
class AmazonMQAMQP091:
2103class AmazonMQAMQP091:
2104    '''
2105
2106    '''
2107    __slots__ = [
2108        'bind_interface',
2109        'egress_filter',
2110        'healthy',
2111        'hostname',
2112        'id',
2113        'name',
2114        'password',
2115        'port',
2116        'port_override',
2117        'secret_store_id',
2118        'tags',
2119        'tls_required',
2120        'username',
2121    ]
2122
2123    def __init__(
2124        self,
2125        bind_interface=None,
2126        egress_filter=None,
2127        healthy=None,
2128        hostname=None,
2129        id=None,
2130        name=None,
2131        password=None,
2132        port=None,
2133        port_override=None,
2134        secret_store_id=None,
2135        tags=None,
2136        tls_required=None,
2137        username=None,
2138    ):
2139        self.bind_interface = bind_interface if bind_interface is not None else ''
2140        '''
2141         Bind interface
2142        '''
2143        self.egress_filter = egress_filter if egress_filter is not None else ''
2144        '''
2145         A filter applied to the routing logic to pin datasource to nodes.
2146        '''
2147        self.healthy = healthy if healthy is not None else False
2148        '''
2149         True if the datasource is reachable and the credentials are valid.
2150        '''
2151        self.hostname = hostname if hostname is not None else ''
2152        '''
2153
2154        '''
2155        self.id = id if id is not None else ''
2156        '''
2157         Unique identifier of the Resource.
2158        '''
2159        self.name = name if name is not None else ''
2160        '''
2161         Unique human-readable name of the Resource.
2162        '''
2163        self.password = password if password is not None else ''
2164        '''
2165
2166        '''
2167        self.port = port if port is not None else 0
2168        '''
2169
2170        '''
2171        self.port_override = port_override if port_override is not None else 0
2172        '''
2173
2174        '''
2175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2176        '''
2177         ID of the secret store containing credentials for this resource, if any.
2178        '''
2179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2180        '''
2181         Tags is a map of key, value pairs.
2182        '''
2183        self.tls_required = tls_required if tls_required is not None else False
2184        '''
2185
2186        '''
2187        self.username = username if username is not None else ''
2188        '''
2189
2190        '''
2191
2192    def __repr__(self):
2193        return '<sdm.AmazonMQAMQP091 ' + \
2194            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2196            'healthy: ' + repr(self.healthy) + ' ' +\
2197            'hostname: ' + repr(self.hostname) + ' ' +\
2198            'id: ' + repr(self.id) + ' ' +\
2199            'name: ' + repr(self.name) + ' ' +\
2200            'password: ' + repr(self.password) + ' ' +\
2201            'port: ' + repr(self.port) + ' ' +\
2202            'port_override: ' + repr(self.port_override) + ' ' +\
2203            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2204            'tags: ' + repr(self.tags) + ' ' +\
2205            'tls_required: ' + repr(self.tls_required) + ' ' +\
2206            'username: ' + repr(self.username) + ' ' +\
2207            '>'
2208
2209    def to_dict(self):
2210        return {
2211            'bind_interface': self.bind_interface,
2212            'egress_filter': self.egress_filter,
2213            'healthy': self.healthy,
2214            'hostname': self.hostname,
2215            'id': self.id,
2216            'name': self.name,
2217            'password': self.password,
2218            'port': self.port,
2219            'port_override': self.port_override,
2220            'secret_store_id': self.secret_store_id,
2221            'tags': self.tags,
2222            'tls_required': self.tls_required,
2223            'username': self.username,
2224        }
2225
2226    @classmethod
2227    def from_dict(cls, d):
2228        return cls(
2229            bind_interface=d.get('bind_interface'),
2230            egress_filter=d.get('egress_filter'),
2231            healthy=d.get('healthy'),
2232            hostname=d.get('hostname'),
2233            id=d.get('id'),
2234            name=d.get('name'),
2235            password=d.get('password'),
2236            port=d.get('port'),
2237            port_override=d.get('port_override'),
2238            secret_store_id=d.get('secret_store_id'),
2239            tags=d.get('tags'),
2240            tls_required=d.get('tls_required'),
2241            username=d.get('username'),
2242        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2123    def __init__(
2124        self,
2125        bind_interface=None,
2126        egress_filter=None,
2127        healthy=None,
2128        hostname=None,
2129        id=None,
2130        name=None,
2131        password=None,
2132        port=None,
2133        port_override=None,
2134        secret_store_id=None,
2135        tags=None,
2136        tls_required=None,
2137        username=None,
2138    ):
2139        self.bind_interface = bind_interface if bind_interface is not None else ''
2140        '''
2141         Bind interface
2142        '''
2143        self.egress_filter = egress_filter if egress_filter is not None else ''
2144        '''
2145         A filter applied to the routing logic to pin datasource to nodes.
2146        '''
2147        self.healthy = healthy if healthy is not None else False
2148        '''
2149         True if the datasource is reachable and the credentials are valid.
2150        '''
2151        self.hostname = hostname if hostname is not None else ''
2152        '''
2153
2154        '''
2155        self.id = id if id is not None else ''
2156        '''
2157         Unique identifier of the Resource.
2158        '''
2159        self.name = name if name is not None else ''
2160        '''
2161         Unique human-readable name of the Resource.
2162        '''
2163        self.password = password if password is not None else ''
2164        '''
2165
2166        '''
2167        self.port = port if port is not None else 0
2168        '''
2169
2170        '''
2171        self.port_override = port_override if port_override is not None else 0
2172        '''
2173
2174        '''
2175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2176        '''
2177         ID of the secret store containing credentials for this resource, if any.
2178        '''
2179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2180        '''
2181         Tags is a map of key, value pairs.
2182        '''
2183        self.tls_required = tls_required if tls_required is not None else False
2184        '''
2185
2186        '''
2187        self.username = username if username is not None else ''
2188        '''
2189
2190        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2209    def to_dict(self):
2210        return {
2211            'bind_interface': self.bind_interface,
2212            'egress_filter': self.egress_filter,
2213            'healthy': self.healthy,
2214            'hostname': self.hostname,
2215            'id': self.id,
2216            'name': self.name,
2217            'password': self.password,
2218            'port': self.port,
2219            'port_override': self.port_override,
2220            'secret_store_id': self.secret_store_id,
2221            'tags': self.tags,
2222            'tls_required': self.tls_required,
2223            'username': self.username,
2224        }
@classmethod
def from_dict(cls, d)
2226    @classmethod
2227    def from_dict(cls, d):
2228        return cls(
2229            bind_interface=d.get('bind_interface'),
2230            egress_filter=d.get('egress_filter'),
2231            healthy=d.get('healthy'),
2232            hostname=d.get('hostname'),
2233            id=d.get('id'),
2234            name=d.get('name'),
2235            password=d.get('password'),
2236            port=d.get('port'),
2237            port_override=d.get('port_override'),
2238            secret_store_id=d.get('secret_store_id'),
2239            tags=d.get('tags'),
2240            tls_required=d.get('tls_required'),
2241            username=d.get('username'),
2242        )
class Athena:
2245class Athena:
2246    '''
2247
2248    '''
2249    __slots__ = [
2250        'access_key',
2251        'bind_interface',
2252        'egress_filter',
2253        'healthy',
2254        'id',
2255        'name',
2256        'output',
2257        'port_override',
2258        'region',
2259        'role_arn',
2260        'role_external_id',
2261        'secret_access_key',
2262        'secret_store_id',
2263        'tags',
2264    ]
2265
2266    def __init__(
2267        self,
2268        access_key=None,
2269        bind_interface=None,
2270        egress_filter=None,
2271        healthy=None,
2272        id=None,
2273        name=None,
2274        output=None,
2275        port_override=None,
2276        region=None,
2277        role_arn=None,
2278        role_external_id=None,
2279        secret_access_key=None,
2280        secret_store_id=None,
2281        tags=None,
2282    ):
2283        self.access_key = access_key if access_key is not None else ''
2284        '''
2285
2286        '''
2287        self.bind_interface = bind_interface if bind_interface is not None else ''
2288        '''
2289         Bind interface
2290        '''
2291        self.egress_filter = egress_filter if egress_filter is not None else ''
2292        '''
2293         A filter applied to the routing logic to pin datasource to nodes.
2294        '''
2295        self.healthy = healthy if healthy is not None else False
2296        '''
2297         True if the datasource is reachable and the credentials are valid.
2298        '''
2299        self.id = id if id is not None else ''
2300        '''
2301         Unique identifier of the Resource.
2302        '''
2303        self.name = name if name is not None else ''
2304        '''
2305         Unique human-readable name of the Resource.
2306        '''
2307        self.output = output if output is not None else ''
2308        '''
2309
2310        '''
2311        self.port_override = port_override if port_override is not None else 0
2312        '''
2313
2314        '''
2315        self.region = region if region is not None else ''
2316        '''
2317
2318        '''
2319        self.role_arn = role_arn if role_arn is not None else ''
2320        '''
2321
2322        '''
2323        self.role_external_id = role_external_id if role_external_id is not None else ''
2324        '''
2325
2326        '''
2327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2328        '''
2329
2330        '''
2331        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2332        '''
2333         ID of the secret store containing credentials for this resource, if any.
2334        '''
2335        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2336        '''
2337         Tags is a map of key, value pairs.
2338        '''
2339
2340    def __repr__(self):
2341        return '<sdm.Athena ' + \
2342            'access_key: ' + repr(self.access_key) + ' ' +\
2343            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2344            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2345            'healthy: ' + repr(self.healthy) + ' ' +\
2346            'id: ' + repr(self.id) + ' ' +\
2347            'name: ' + repr(self.name) + ' ' +\
2348            'output: ' + repr(self.output) + ' ' +\
2349            'port_override: ' + repr(self.port_override) + ' ' +\
2350            'region: ' + repr(self.region) + ' ' +\
2351            'role_arn: ' + repr(self.role_arn) + ' ' +\
2352            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2353            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2354            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2355            'tags: ' + repr(self.tags) + ' ' +\
2356            '>'
2357
2358    def to_dict(self):
2359        return {
2360            'access_key': self.access_key,
2361            'bind_interface': self.bind_interface,
2362            'egress_filter': self.egress_filter,
2363            'healthy': self.healthy,
2364            'id': self.id,
2365            'name': self.name,
2366            'output': self.output,
2367            'port_override': self.port_override,
2368            'region': self.region,
2369            'role_arn': self.role_arn,
2370            'role_external_id': self.role_external_id,
2371            'secret_access_key': self.secret_access_key,
2372            'secret_store_id': self.secret_store_id,
2373            'tags': self.tags,
2374        }
2375
2376    @classmethod
2377    def from_dict(cls, d):
2378        return cls(
2379            access_key=d.get('access_key'),
2380            bind_interface=d.get('bind_interface'),
2381            egress_filter=d.get('egress_filter'),
2382            healthy=d.get('healthy'),
2383            id=d.get('id'),
2384            name=d.get('name'),
2385            output=d.get('output'),
2386            port_override=d.get('port_override'),
2387            region=d.get('region'),
2388            role_arn=d.get('role_arn'),
2389            role_external_id=d.get('role_external_id'),
2390            secret_access_key=d.get('secret_access_key'),
2391            secret_store_id=d.get('secret_store_id'),
2392            tags=d.get('tags'),
2393        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2266    def __init__(
2267        self,
2268        access_key=None,
2269        bind_interface=None,
2270        egress_filter=None,
2271        healthy=None,
2272        id=None,
2273        name=None,
2274        output=None,
2275        port_override=None,
2276        region=None,
2277        role_arn=None,
2278        role_external_id=None,
2279        secret_access_key=None,
2280        secret_store_id=None,
2281        tags=None,
2282    ):
2283        self.access_key = access_key if access_key is not None else ''
2284        '''
2285
2286        '''
2287        self.bind_interface = bind_interface if bind_interface is not None else ''
2288        '''
2289         Bind interface
2290        '''
2291        self.egress_filter = egress_filter if egress_filter is not None else ''
2292        '''
2293         A filter applied to the routing logic to pin datasource to nodes.
2294        '''
2295        self.healthy = healthy if healthy is not None else False
2296        '''
2297         True if the datasource is reachable and the credentials are valid.
2298        '''
2299        self.id = id if id is not None else ''
2300        '''
2301         Unique identifier of the Resource.
2302        '''
2303        self.name = name if name is not None else ''
2304        '''
2305         Unique human-readable name of the Resource.
2306        '''
2307        self.output = output if output is not None else ''
2308        '''
2309
2310        '''
2311        self.port_override = port_override if port_override is not None else 0
2312        '''
2313
2314        '''
2315        self.region = region if region is not None else ''
2316        '''
2317
2318        '''
2319        self.role_arn = role_arn if role_arn is not None else ''
2320        '''
2321
2322        '''
2323        self.role_external_id = role_external_id if role_external_id is not None else ''
2324        '''
2325
2326        '''
2327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2328        '''
2329
2330        '''
2331        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2332        '''
2333         ID of the secret store containing credentials for this resource, if any.
2334        '''
2335        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2336        '''
2337         Tags is a map of key, value pairs.
2338        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2358    def to_dict(self):
2359        return {
2360            'access_key': self.access_key,
2361            'bind_interface': self.bind_interface,
2362            'egress_filter': self.egress_filter,
2363            'healthy': self.healthy,
2364            'id': self.id,
2365            'name': self.name,
2366            'output': self.output,
2367            'port_override': self.port_override,
2368            'region': self.region,
2369            'role_arn': self.role_arn,
2370            'role_external_id': self.role_external_id,
2371            'secret_access_key': self.secret_access_key,
2372            'secret_store_id': self.secret_store_id,
2373            'tags': self.tags,
2374        }
@classmethod
def from_dict(cls, d)
2376    @classmethod
2377    def from_dict(cls, d):
2378        return cls(
2379            access_key=d.get('access_key'),
2380            bind_interface=d.get('bind_interface'),
2381            egress_filter=d.get('egress_filter'),
2382            healthy=d.get('healthy'),
2383            id=d.get('id'),
2384            name=d.get('name'),
2385            output=d.get('output'),
2386            port_override=d.get('port_override'),
2387            region=d.get('region'),
2388            role_arn=d.get('role_arn'),
2389            role_external_id=d.get('role_external_id'),
2390            secret_access_key=d.get('secret_access_key'),
2391            secret_store_id=d.get('secret_store_id'),
2392            tags=d.get('tags'),
2393        )
class AuroraMysql:
2396class AuroraMysql:
2397    '''
2398
2399    '''
2400    __slots__ = [
2401        'bind_interface',
2402        'database',
2403        'egress_filter',
2404        'healthy',
2405        'hostname',
2406        'id',
2407        'name',
2408        'password',
2409        'port',
2410        'port_override',
2411        'secret_store_id',
2412        'tags',
2413        'username',
2414    ]
2415
2416    def __init__(
2417        self,
2418        bind_interface=None,
2419        database=None,
2420        egress_filter=None,
2421        healthy=None,
2422        hostname=None,
2423        id=None,
2424        name=None,
2425        password=None,
2426        port=None,
2427        port_override=None,
2428        secret_store_id=None,
2429        tags=None,
2430        username=None,
2431    ):
2432        self.bind_interface = bind_interface if bind_interface is not None else ''
2433        '''
2434         Bind interface
2435        '''
2436        self.database = database if database is not None else ''
2437        '''
2438
2439        '''
2440        self.egress_filter = egress_filter if egress_filter is not None else ''
2441        '''
2442         A filter applied to the routing logic to pin datasource to nodes.
2443        '''
2444        self.healthy = healthy if healthy is not None else False
2445        '''
2446         True if the datasource is reachable and the credentials are valid.
2447        '''
2448        self.hostname = hostname if hostname is not None else ''
2449        '''
2450
2451        '''
2452        self.id = id if id is not None else ''
2453        '''
2454         Unique identifier of the Resource.
2455        '''
2456        self.name = name if name is not None else ''
2457        '''
2458         Unique human-readable name of the Resource.
2459        '''
2460        self.password = password if password is not None else ''
2461        '''
2462
2463        '''
2464        self.port = port if port is not None else 0
2465        '''
2466
2467        '''
2468        self.port_override = port_override if port_override is not None else 0
2469        '''
2470
2471        '''
2472        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2473        '''
2474         ID of the secret store containing credentials for this resource, if any.
2475        '''
2476        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2477        '''
2478         Tags is a map of key, value pairs.
2479        '''
2480        self.username = username if username is not None else ''
2481        '''
2482
2483        '''
2484
2485    def __repr__(self):
2486        return '<sdm.AuroraMysql ' + \
2487            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2488            'database: ' + repr(self.database) + ' ' +\
2489            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2490            'healthy: ' + repr(self.healthy) + ' ' +\
2491            'hostname: ' + repr(self.hostname) + ' ' +\
2492            'id: ' + repr(self.id) + ' ' +\
2493            'name: ' + repr(self.name) + ' ' +\
2494            'password: ' + repr(self.password) + ' ' +\
2495            'port: ' + repr(self.port) + ' ' +\
2496            'port_override: ' + repr(self.port_override) + ' ' +\
2497            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2498            'tags: ' + repr(self.tags) + ' ' +\
2499            'username: ' + repr(self.username) + ' ' +\
2500            '>'
2501
2502    def to_dict(self):
2503        return {
2504            'bind_interface': self.bind_interface,
2505            'database': self.database,
2506            'egress_filter': self.egress_filter,
2507            'healthy': self.healthy,
2508            'hostname': self.hostname,
2509            'id': self.id,
2510            'name': self.name,
2511            'password': self.password,
2512            'port': self.port,
2513            'port_override': self.port_override,
2514            'secret_store_id': self.secret_store_id,
2515            'tags': self.tags,
2516            'username': self.username,
2517        }
2518
2519    @classmethod
2520    def from_dict(cls, d):
2521        return cls(
2522            bind_interface=d.get('bind_interface'),
2523            database=d.get('database'),
2524            egress_filter=d.get('egress_filter'),
2525            healthy=d.get('healthy'),
2526            hostname=d.get('hostname'),
2527            id=d.get('id'),
2528            name=d.get('name'),
2529            password=d.get('password'),
2530            port=d.get('port'),
2531            port_override=d.get('port_override'),
2532            secret_store_id=d.get('secret_store_id'),
2533            tags=d.get('tags'),
2534            username=d.get('username'),
2535        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2416    def __init__(
2417        self,
2418        bind_interface=None,
2419        database=None,
2420        egress_filter=None,
2421        healthy=None,
2422        hostname=None,
2423        id=None,
2424        name=None,
2425        password=None,
2426        port=None,
2427        port_override=None,
2428        secret_store_id=None,
2429        tags=None,
2430        username=None,
2431    ):
2432        self.bind_interface = bind_interface if bind_interface is not None else ''
2433        '''
2434         Bind interface
2435        '''
2436        self.database = database if database is not None else ''
2437        '''
2438
2439        '''
2440        self.egress_filter = egress_filter if egress_filter is not None else ''
2441        '''
2442         A filter applied to the routing logic to pin datasource to nodes.
2443        '''
2444        self.healthy = healthy if healthy is not None else False
2445        '''
2446         True if the datasource is reachable and the credentials are valid.
2447        '''
2448        self.hostname = hostname if hostname is not None else ''
2449        '''
2450
2451        '''
2452        self.id = id if id is not None else ''
2453        '''
2454         Unique identifier of the Resource.
2455        '''
2456        self.name = name if name is not None else ''
2457        '''
2458         Unique human-readable name of the Resource.
2459        '''
2460        self.password = password if password is not None else ''
2461        '''
2462
2463        '''
2464        self.port = port if port is not None else 0
2465        '''
2466
2467        '''
2468        self.port_override = port_override if port_override is not None else 0
2469        '''
2470
2471        '''
2472        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2473        '''
2474         ID of the secret store containing credentials for this resource, if any.
2475        '''
2476        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2477        '''
2478         Tags is a map of key, value pairs.
2479        '''
2480        self.username = username if username is not None else ''
2481        '''
2482
2483        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2502    def to_dict(self):
2503        return {
2504            'bind_interface': self.bind_interface,
2505            'database': self.database,
2506            'egress_filter': self.egress_filter,
2507            'healthy': self.healthy,
2508            'hostname': self.hostname,
2509            'id': self.id,
2510            'name': self.name,
2511            'password': self.password,
2512            'port': self.port,
2513            'port_override': self.port_override,
2514            'secret_store_id': self.secret_store_id,
2515            'tags': self.tags,
2516            'username': self.username,
2517        }
@classmethod
def from_dict(cls, d)
2519    @classmethod
2520    def from_dict(cls, d):
2521        return cls(
2522            bind_interface=d.get('bind_interface'),
2523            database=d.get('database'),
2524            egress_filter=d.get('egress_filter'),
2525            healthy=d.get('healthy'),
2526            hostname=d.get('hostname'),
2527            id=d.get('id'),
2528            name=d.get('name'),
2529            password=d.get('password'),
2530            port=d.get('port'),
2531            port_override=d.get('port_override'),
2532            secret_store_id=d.get('secret_store_id'),
2533            tags=d.get('tags'),
2534            username=d.get('username'),
2535        )
class AuroraPostgres:
2538class AuroraPostgres:
2539    '''
2540
2541    '''
2542    __slots__ = [
2543        'bind_interface',
2544        'database',
2545        'egress_filter',
2546        'healthy',
2547        'hostname',
2548        'id',
2549        'name',
2550        'override_database',
2551        'password',
2552        'port',
2553        'port_override',
2554        'secret_store_id',
2555        'tags',
2556        'username',
2557    ]
2558
2559    def __init__(
2560        self,
2561        bind_interface=None,
2562        database=None,
2563        egress_filter=None,
2564        healthy=None,
2565        hostname=None,
2566        id=None,
2567        name=None,
2568        override_database=None,
2569        password=None,
2570        port=None,
2571        port_override=None,
2572        secret_store_id=None,
2573        tags=None,
2574        username=None,
2575    ):
2576        self.bind_interface = bind_interface if bind_interface is not None else ''
2577        '''
2578         Bind interface
2579        '''
2580        self.database = database if database is not None else ''
2581        '''
2582
2583        '''
2584        self.egress_filter = egress_filter if egress_filter is not None else ''
2585        '''
2586         A filter applied to the routing logic to pin datasource to nodes.
2587        '''
2588        self.healthy = healthy if healthy is not None else False
2589        '''
2590         True if the datasource is reachable and the credentials are valid.
2591        '''
2592        self.hostname = hostname if hostname is not None else ''
2593        '''
2594
2595        '''
2596        self.id = id if id is not None else ''
2597        '''
2598         Unique identifier of the Resource.
2599        '''
2600        self.name = name if name is not None else ''
2601        '''
2602         Unique human-readable name of the Resource.
2603        '''
2604        self.override_database = override_database if override_database is not None else False
2605        '''
2606
2607        '''
2608        self.password = password if password is not None else ''
2609        '''
2610
2611        '''
2612        self.port = port if port is not None else 0
2613        '''
2614
2615        '''
2616        self.port_override = port_override if port_override is not None else 0
2617        '''
2618
2619        '''
2620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2621        '''
2622         ID of the secret store containing credentials for this resource, if any.
2623        '''
2624        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2625        '''
2626         Tags is a map of key, value pairs.
2627        '''
2628        self.username = username if username is not None else ''
2629        '''
2630
2631        '''
2632
2633    def __repr__(self):
2634        return '<sdm.AuroraPostgres ' + \
2635            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2636            'database: ' + repr(self.database) + ' ' +\
2637            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2638            'healthy: ' + repr(self.healthy) + ' ' +\
2639            'hostname: ' + repr(self.hostname) + ' ' +\
2640            'id: ' + repr(self.id) + ' ' +\
2641            'name: ' + repr(self.name) + ' ' +\
2642            'override_database: ' + repr(self.override_database) + ' ' +\
2643            'password: ' + repr(self.password) + ' ' +\
2644            'port: ' + repr(self.port) + ' ' +\
2645            'port_override: ' + repr(self.port_override) + ' ' +\
2646            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2647            'tags: ' + repr(self.tags) + ' ' +\
2648            'username: ' + repr(self.username) + ' ' +\
2649            '>'
2650
2651    def to_dict(self):
2652        return {
2653            'bind_interface': self.bind_interface,
2654            'database': self.database,
2655            'egress_filter': self.egress_filter,
2656            'healthy': self.healthy,
2657            'hostname': self.hostname,
2658            'id': self.id,
2659            'name': self.name,
2660            'override_database': self.override_database,
2661            'password': self.password,
2662            'port': self.port,
2663            'port_override': self.port_override,
2664            'secret_store_id': self.secret_store_id,
2665            'tags': self.tags,
2666            'username': self.username,
2667        }
2668
2669    @classmethod
2670    def from_dict(cls, d):
2671        return cls(
2672            bind_interface=d.get('bind_interface'),
2673            database=d.get('database'),
2674            egress_filter=d.get('egress_filter'),
2675            healthy=d.get('healthy'),
2676            hostname=d.get('hostname'),
2677            id=d.get('id'),
2678            name=d.get('name'),
2679            override_database=d.get('override_database'),
2680            password=d.get('password'),
2681            port=d.get('port'),
2682            port_override=d.get('port_override'),
2683            secret_store_id=d.get('secret_store_id'),
2684            tags=d.get('tags'),
2685            username=d.get('username'),
2686        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2559    def __init__(
2560        self,
2561        bind_interface=None,
2562        database=None,
2563        egress_filter=None,
2564        healthy=None,
2565        hostname=None,
2566        id=None,
2567        name=None,
2568        override_database=None,
2569        password=None,
2570        port=None,
2571        port_override=None,
2572        secret_store_id=None,
2573        tags=None,
2574        username=None,
2575    ):
2576        self.bind_interface = bind_interface if bind_interface is not None else ''
2577        '''
2578         Bind interface
2579        '''
2580        self.database = database if database is not None else ''
2581        '''
2582
2583        '''
2584        self.egress_filter = egress_filter if egress_filter is not None else ''
2585        '''
2586         A filter applied to the routing logic to pin datasource to nodes.
2587        '''
2588        self.healthy = healthy if healthy is not None else False
2589        '''
2590         True if the datasource is reachable and the credentials are valid.
2591        '''
2592        self.hostname = hostname if hostname is not None else ''
2593        '''
2594
2595        '''
2596        self.id = id if id is not None else ''
2597        '''
2598         Unique identifier of the Resource.
2599        '''
2600        self.name = name if name is not None else ''
2601        '''
2602         Unique human-readable name of the Resource.
2603        '''
2604        self.override_database = override_database if override_database is not None else False
2605        '''
2606
2607        '''
2608        self.password = password if password is not None else ''
2609        '''
2610
2611        '''
2612        self.port = port if port is not None else 0
2613        '''
2614
2615        '''
2616        self.port_override = port_override if port_override is not None else 0
2617        '''
2618
2619        '''
2620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2621        '''
2622         ID of the secret store containing credentials for this resource, if any.
2623        '''
2624        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2625        '''
2626         Tags is a map of key, value pairs.
2627        '''
2628        self.username = username if username is not None else ''
2629        '''
2630
2631        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2651    def to_dict(self):
2652        return {
2653            'bind_interface': self.bind_interface,
2654            'database': self.database,
2655            'egress_filter': self.egress_filter,
2656            'healthy': self.healthy,
2657            'hostname': self.hostname,
2658            'id': self.id,
2659            'name': self.name,
2660            'override_database': self.override_database,
2661            'password': self.password,
2662            'port': self.port,
2663            'port_override': self.port_override,
2664            'secret_store_id': self.secret_store_id,
2665            'tags': self.tags,
2666            'username': self.username,
2667        }
@classmethod
def from_dict(cls, d)
2669    @classmethod
2670    def from_dict(cls, d):
2671        return cls(
2672            bind_interface=d.get('bind_interface'),
2673            database=d.get('database'),
2674            egress_filter=d.get('egress_filter'),
2675            healthy=d.get('healthy'),
2676            hostname=d.get('hostname'),
2677            id=d.get('id'),
2678            name=d.get('name'),
2679            override_database=d.get('override_database'),
2680            password=d.get('password'),
2681            port=d.get('port'),
2682            port_override=d.get('port_override'),
2683            secret_store_id=d.get('secret_store_id'),
2684            tags=d.get('tags'),
2685            username=d.get('username'),
2686        )
class Azure:
2689class Azure:
2690    '''
2691
2692    '''
2693    __slots__ = [
2694        'app_id',
2695        'bind_interface',
2696        'egress_filter',
2697        'healthy',
2698        'id',
2699        'name',
2700        'password',
2701        'secret_store_id',
2702        'tags',
2703        'tenant_id',
2704    ]
2705
2706    def __init__(
2707        self,
2708        app_id=None,
2709        bind_interface=None,
2710        egress_filter=None,
2711        healthy=None,
2712        id=None,
2713        name=None,
2714        password=None,
2715        secret_store_id=None,
2716        tags=None,
2717        tenant_id=None,
2718    ):
2719        self.app_id = app_id if app_id is not None else ''
2720        '''
2721
2722        '''
2723        self.bind_interface = bind_interface if bind_interface is not None else ''
2724        '''
2725         Bind interface
2726        '''
2727        self.egress_filter = egress_filter if egress_filter is not None else ''
2728        '''
2729         A filter applied to the routing logic to pin datasource to nodes.
2730        '''
2731        self.healthy = healthy if healthy is not None else False
2732        '''
2733         True if the datasource is reachable and the credentials are valid.
2734        '''
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the Resource.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the Resource.
2742        '''
2743        self.password = password if password is not None else ''
2744        '''
2745
2746        '''
2747        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2748        '''
2749         ID of the secret store containing credentials for this resource, if any.
2750        '''
2751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2752        '''
2753         Tags is a map of key, value pairs.
2754        '''
2755        self.tenant_id = tenant_id if tenant_id is not None else ''
2756        '''
2757
2758        '''
2759
2760    def __repr__(self):
2761        return '<sdm.Azure ' + \
2762            'app_id: ' + repr(self.app_id) + ' ' +\
2763            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2764            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2765            'healthy: ' + repr(self.healthy) + ' ' +\
2766            'id: ' + repr(self.id) + ' ' +\
2767            'name: ' + repr(self.name) + ' ' +\
2768            'password: ' + repr(self.password) + ' ' +\
2769            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2770            'tags: ' + repr(self.tags) + ' ' +\
2771            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2772            '>'
2773
2774    def to_dict(self):
2775        return {
2776            'app_id': self.app_id,
2777            'bind_interface': self.bind_interface,
2778            'egress_filter': self.egress_filter,
2779            'healthy': self.healthy,
2780            'id': self.id,
2781            'name': self.name,
2782            'password': self.password,
2783            'secret_store_id': self.secret_store_id,
2784            'tags': self.tags,
2785            'tenant_id': self.tenant_id,
2786        }
2787
2788    @classmethod
2789    def from_dict(cls, d):
2790        return cls(
2791            app_id=d.get('app_id'),
2792            bind_interface=d.get('bind_interface'),
2793            egress_filter=d.get('egress_filter'),
2794            healthy=d.get('healthy'),
2795            id=d.get('id'),
2796            name=d.get('name'),
2797            password=d.get('password'),
2798            secret_store_id=d.get('secret_store_id'),
2799            tags=d.get('tags'),
2800            tenant_id=d.get('tenant_id'),
2801        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2706    def __init__(
2707        self,
2708        app_id=None,
2709        bind_interface=None,
2710        egress_filter=None,
2711        healthy=None,
2712        id=None,
2713        name=None,
2714        password=None,
2715        secret_store_id=None,
2716        tags=None,
2717        tenant_id=None,
2718    ):
2719        self.app_id = app_id if app_id is not None else ''
2720        '''
2721
2722        '''
2723        self.bind_interface = bind_interface if bind_interface is not None else ''
2724        '''
2725         Bind interface
2726        '''
2727        self.egress_filter = egress_filter if egress_filter is not None else ''
2728        '''
2729         A filter applied to the routing logic to pin datasource to nodes.
2730        '''
2731        self.healthy = healthy if healthy is not None else False
2732        '''
2733         True if the datasource is reachable and the credentials are valid.
2734        '''
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the Resource.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the Resource.
2742        '''
2743        self.password = password if password is not None else ''
2744        '''
2745
2746        '''
2747        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2748        '''
2749         ID of the secret store containing credentials for this resource, if any.
2750        '''
2751        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2752        '''
2753         Tags is a map of key, value pairs.
2754        '''
2755        self.tenant_id = tenant_id if tenant_id is not None else ''
2756        '''
2757
2758        '''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2774    def to_dict(self):
2775        return {
2776            'app_id': self.app_id,
2777            'bind_interface': self.bind_interface,
2778            'egress_filter': self.egress_filter,
2779            'healthy': self.healthy,
2780            'id': self.id,
2781            'name': self.name,
2782            'password': self.password,
2783            'secret_store_id': self.secret_store_id,
2784            'tags': self.tags,
2785            'tenant_id': self.tenant_id,
2786        }
@classmethod
def from_dict(cls, d)
2788    @classmethod
2789    def from_dict(cls, d):
2790        return cls(
2791            app_id=d.get('app_id'),
2792            bind_interface=d.get('bind_interface'),
2793            egress_filter=d.get('egress_filter'),
2794            healthy=d.get('healthy'),
2795            id=d.get('id'),
2796            name=d.get('name'),
2797            password=d.get('password'),
2798            secret_store_id=d.get('secret_store_id'),
2799            tags=d.get('tags'),
2800            tenant_id=d.get('tenant_id'),
2801        )
class AzureCertificate:
2804class AzureCertificate:
2805    '''
2806
2807    '''
2808    __slots__ = [
2809        'app_id',
2810        'bind_interface',
2811        'client_certificate',
2812        'egress_filter',
2813        'healthy',
2814        'id',
2815        'name',
2816        'secret_store_id',
2817        'tags',
2818        'tenant_id',
2819    ]
2820
2821    def __init__(
2822        self,
2823        app_id=None,
2824        bind_interface=None,
2825        client_certificate=None,
2826        egress_filter=None,
2827        healthy=None,
2828        id=None,
2829        name=None,
2830        secret_store_id=None,
2831        tags=None,
2832        tenant_id=None,
2833    ):
2834        self.app_id = app_id if app_id is not None else ''
2835        '''
2836
2837        '''
2838        self.bind_interface = bind_interface if bind_interface is not None else ''
2839        '''
2840         Bind interface
2841        '''
2842        self.client_certificate = client_certificate if client_certificate is not None else ''
2843        '''
2844
2845        '''
2846        self.egress_filter = egress_filter if egress_filter is not None else ''
2847        '''
2848         A filter applied to the routing logic to pin datasource to nodes.
2849        '''
2850        self.healthy = healthy if healthy is not None else False
2851        '''
2852         True if the datasource is reachable and the credentials are valid.
2853        '''
2854        self.id = id if id is not None else ''
2855        '''
2856         Unique identifier of the Resource.
2857        '''
2858        self.name = name if name is not None else ''
2859        '''
2860         Unique human-readable name of the Resource.
2861        '''
2862        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2863        '''
2864         ID of the secret store containing credentials for this resource, if any.
2865        '''
2866        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2867        '''
2868         Tags is a map of key, value pairs.
2869        '''
2870        self.tenant_id = tenant_id if tenant_id is not None else ''
2871        '''
2872
2873        '''
2874
2875    def __repr__(self):
2876        return '<sdm.AzureCertificate ' + \
2877            'app_id: ' + repr(self.app_id) + ' ' +\
2878            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2879            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2880            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2881            'healthy: ' + repr(self.healthy) + ' ' +\
2882            'id: ' + repr(self.id) + ' ' +\
2883            'name: ' + repr(self.name) + ' ' +\
2884            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2885            'tags: ' + repr(self.tags) + ' ' +\
2886            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2887            '>'
2888
2889    def to_dict(self):
2890        return {
2891            'app_id': self.app_id,
2892            'bind_interface': self.bind_interface,
2893            'client_certificate': self.client_certificate,
2894            'egress_filter': self.egress_filter,
2895            'healthy': self.healthy,
2896            'id': self.id,
2897            'name': self.name,
2898            'secret_store_id': self.secret_store_id,
2899            'tags': self.tags,
2900            'tenant_id': self.tenant_id,
2901        }
2902
2903    @classmethod
2904    def from_dict(cls, d):
2905        return cls(
2906            app_id=d.get('app_id'),
2907            bind_interface=d.get('bind_interface'),
2908            client_certificate=d.get('client_certificate'),
2909            egress_filter=d.get('egress_filter'),
2910            healthy=d.get('healthy'),
2911            id=d.get('id'),
2912            name=d.get('name'),
2913            secret_store_id=d.get('secret_store_id'),
2914            tags=d.get('tags'),
2915            tenant_id=d.get('tenant_id'),
2916        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2821    def __init__(
2822        self,
2823        app_id=None,
2824        bind_interface=None,
2825        client_certificate=None,
2826        egress_filter=None,
2827        healthy=None,
2828        id=None,
2829        name=None,
2830        secret_store_id=None,
2831        tags=None,
2832        tenant_id=None,
2833    ):
2834        self.app_id = app_id if app_id is not None else ''
2835        '''
2836
2837        '''
2838        self.bind_interface = bind_interface if bind_interface is not None else ''
2839        '''
2840         Bind interface
2841        '''
2842        self.client_certificate = client_certificate if client_certificate is not None else ''
2843        '''
2844
2845        '''
2846        self.egress_filter = egress_filter if egress_filter is not None else ''
2847        '''
2848         A filter applied to the routing logic to pin datasource to nodes.
2849        '''
2850        self.healthy = healthy if healthy is not None else False
2851        '''
2852         True if the datasource is reachable and the credentials are valid.
2853        '''
2854        self.id = id if id is not None else ''
2855        '''
2856         Unique identifier of the Resource.
2857        '''
2858        self.name = name if name is not None else ''
2859        '''
2860         Unique human-readable name of the Resource.
2861        '''
2862        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2863        '''
2864         ID of the secret store containing credentials for this resource, if any.
2865        '''
2866        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2867        '''
2868         Tags is a map of key, value pairs.
2869        '''
2870        self.tenant_id = tenant_id if tenant_id is not None else ''
2871        '''
2872
2873        '''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2889    def to_dict(self):
2890        return {
2891            'app_id': self.app_id,
2892            'bind_interface': self.bind_interface,
2893            'client_certificate': self.client_certificate,
2894            'egress_filter': self.egress_filter,
2895            'healthy': self.healthy,
2896            'id': self.id,
2897            'name': self.name,
2898            'secret_store_id': self.secret_store_id,
2899            'tags': self.tags,
2900            'tenant_id': self.tenant_id,
2901        }
@classmethod
def from_dict(cls, d)
2903    @classmethod
2904    def from_dict(cls, d):
2905        return cls(
2906            app_id=d.get('app_id'),
2907            bind_interface=d.get('bind_interface'),
2908            client_certificate=d.get('client_certificate'),
2909            egress_filter=d.get('egress_filter'),
2910            healthy=d.get('healthy'),
2911            id=d.get('id'),
2912            name=d.get('name'),
2913            secret_store_id=d.get('secret_store_id'),
2914            tags=d.get('tags'),
2915            tenant_id=d.get('tenant_id'),
2916        )
class AzurePostgres:
2919class AzurePostgres:
2920    '''
2921
2922    '''
2923    __slots__ = [
2924        'bind_interface',
2925        'database',
2926        'egress_filter',
2927        'healthy',
2928        'hostname',
2929        'id',
2930        'name',
2931        'override_database',
2932        'password',
2933        'port',
2934        'port_override',
2935        'secret_store_id',
2936        'tags',
2937        'username',
2938    ]
2939
2940    def __init__(
2941        self,
2942        bind_interface=None,
2943        database=None,
2944        egress_filter=None,
2945        healthy=None,
2946        hostname=None,
2947        id=None,
2948        name=None,
2949        override_database=None,
2950        password=None,
2951        port=None,
2952        port_override=None,
2953        secret_store_id=None,
2954        tags=None,
2955        username=None,
2956    ):
2957        self.bind_interface = bind_interface if bind_interface is not None else ''
2958        '''
2959         Bind interface
2960        '''
2961        self.database = database if database is not None else ''
2962        '''
2963
2964        '''
2965        self.egress_filter = egress_filter if egress_filter is not None else ''
2966        '''
2967         A filter applied to the routing logic to pin datasource to nodes.
2968        '''
2969        self.healthy = healthy if healthy is not None else False
2970        '''
2971         True if the datasource is reachable and the credentials are valid.
2972        '''
2973        self.hostname = hostname if hostname is not None else ''
2974        '''
2975
2976        '''
2977        self.id = id if id is not None else ''
2978        '''
2979         Unique identifier of the Resource.
2980        '''
2981        self.name = name if name is not None else ''
2982        '''
2983         Unique human-readable name of the Resource.
2984        '''
2985        self.override_database = override_database if override_database is not None else False
2986        '''
2987
2988        '''
2989        self.password = password if password is not None else ''
2990        '''
2991
2992        '''
2993        self.port = port if port is not None else 0
2994        '''
2995
2996        '''
2997        self.port_override = port_override if port_override is not None else 0
2998        '''
2999
3000        '''
3001        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3002        '''
3003         ID of the secret store containing credentials for this resource, if any.
3004        '''
3005        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3006        '''
3007         Tags is a map of key, value pairs.
3008        '''
3009        self.username = username if username is not None else ''
3010        '''
3011
3012        '''
3013
3014    def __repr__(self):
3015        return '<sdm.AzurePostgres ' + \
3016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3017            'database: ' + repr(self.database) + ' ' +\
3018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3019            'healthy: ' + repr(self.healthy) + ' ' +\
3020            'hostname: ' + repr(self.hostname) + ' ' +\
3021            'id: ' + repr(self.id) + ' ' +\
3022            'name: ' + repr(self.name) + ' ' +\
3023            'override_database: ' + repr(self.override_database) + ' ' +\
3024            'password: ' + repr(self.password) + ' ' +\
3025            'port: ' + repr(self.port) + ' ' +\
3026            'port_override: ' + repr(self.port_override) + ' ' +\
3027            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3028            'tags: ' + repr(self.tags) + ' ' +\
3029            'username: ' + repr(self.username) + ' ' +\
3030            '>'
3031
3032    def to_dict(self):
3033        return {
3034            'bind_interface': self.bind_interface,
3035            'database': self.database,
3036            'egress_filter': self.egress_filter,
3037            'healthy': self.healthy,
3038            'hostname': self.hostname,
3039            'id': self.id,
3040            'name': self.name,
3041            'override_database': self.override_database,
3042            'password': self.password,
3043            'port': self.port,
3044            'port_override': self.port_override,
3045            'secret_store_id': self.secret_store_id,
3046            'tags': self.tags,
3047            'username': self.username,
3048        }
3049
3050    @classmethod
3051    def from_dict(cls, d):
3052        return cls(
3053            bind_interface=d.get('bind_interface'),
3054            database=d.get('database'),
3055            egress_filter=d.get('egress_filter'),
3056            healthy=d.get('healthy'),
3057            hostname=d.get('hostname'),
3058            id=d.get('id'),
3059            name=d.get('name'),
3060            override_database=d.get('override_database'),
3061            password=d.get('password'),
3062            port=d.get('port'),
3063            port_override=d.get('port_override'),
3064            secret_store_id=d.get('secret_store_id'),
3065            tags=d.get('tags'),
3066            username=d.get('username'),
3067        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2940    def __init__(
2941        self,
2942        bind_interface=None,
2943        database=None,
2944        egress_filter=None,
2945        healthy=None,
2946        hostname=None,
2947        id=None,
2948        name=None,
2949        override_database=None,
2950        password=None,
2951        port=None,
2952        port_override=None,
2953        secret_store_id=None,
2954        tags=None,
2955        username=None,
2956    ):
2957        self.bind_interface = bind_interface if bind_interface is not None else ''
2958        '''
2959         Bind interface
2960        '''
2961        self.database = database if database is not None else ''
2962        '''
2963
2964        '''
2965        self.egress_filter = egress_filter if egress_filter is not None else ''
2966        '''
2967         A filter applied to the routing logic to pin datasource to nodes.
2968        '''
2969        self.healthy = healthy if healthy is not None else False
2970        '''
2971         True if the datasource is reachable and the credentials are valid.
2972        '''
2973        self.hostname = hostname if hostname is not None else ''
2974        '''
2975
2976        '''
2977        self.id = id if id is not None else ''
2978        '''
2979         Unique identifier of the Resource.
2980        '''
2981        self.name = name if name is not None else ''
2982        '''
2983         Unique human-readable name of the Resource.
2984        '''
2985        self.override_database = override_database if override_database is not None else False
2986        '''
2987
2988        '''
2989        self.password = password if password is not None else ''
2990        '''
2991
2992        '''
2993        self.port = port if port is not None else 0
2994        '''
2995
2996        '''
2997        self.port_override = port_override if port_override is not None else 0
2998        '''
2999
3000        '''
3001        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3002        '''
3003         ID of the secret store containing credentials for this resource, if any.
3004        '''
3005        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3006        '''
3007         Tags is a map of key, value pairs.
3008        '''
3009        self.username = username if username is not None else ''
3010        '''
3011
3012        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3032    def to_dict(self):
3033        return {
3034            'bind_interface': self.bind_interface,
3035            'database': self.database,
3036            'egress_filter': self.egress_filter,
3037            'healthy': self.healthy,
3038            'hostname': self.hostname,
3039            'id': self.id,
3040            'name': self.name,
3041            'override_database': self.override_database,
3042            'password': self.password,
3043            'port': self.port,
3044            'port_override': self.port_override,
3045            'secret_store_id': self.secret_store_id,
3046            'tags': self.tags,
3047            'username': self.username,
3048        }
@classmethod
def from_dict(cls, d)
3050    @classmethod
3051    def from_dict(cls, d):
3052        return cls(
3053            bind_interface=d.get('bind_interface'),
3054            database=d.get('database'),
3055            egress_filter=d.get('egress_filter'),
3056            healthy=d.get('healthy'),
3057            hostname=d.get('hostname'),
3058            id=d.get('id'),
3059            name=d.get('name'),
3060            override_database=d.get('override_database'),
3061            password=d.get('password'),
3062            port=d.get('port'),
3063            port_override=d.get('port_override'),
3064            secret_store_id=d.get('secret_store_id'),
3065            tags=d.get('tags'),
3066            username=d.get('username'),
3067        )
class AzureStore:
3070class AzureStore:
3071    '''
3072
3073    '''
3074    __slots__ = [
3075        'id',
3076        'name',
3077        'tags',
3078        'vault_uri',
3079    ]
3080
3081    def __init__(
3082        self,
3083        id=None,
3084        name=None,
3085        tags=None,
3086        vault_uri=None,
3087    ):
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the SecretStore.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the SecretStore.
3095        '''
3096        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3097        '''
3098         Tags is a map of key, value pairs.
3099        '''
3100        self.vault_uri = vault_uri if vault_uri is not None else ''
3101        '''
3102
3103        '''
3104
3105    def __repr__(self):
3106        return '<sdm.AzureStore ' + \
3107            'id: ' + repr(self.id) + ' ' +\
3108            'name: ' + repr(self.name) + ' ' +\
3109            'tags: ' + repr(self.tags) + ' ' +\
3110            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3111            '>'
3112
3113    def to_dict(self):
3114        return {
3115            'id': self.id,
3116            'name': self.name,
3117            'tags': self.tags,
3118            'vault_uri': self.vault_uri,
3119        }
3120
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            id=d.get('id'),
3125            name=d.get('name'),
3126            tags=d.get('tags'),
3127            vault_uri=d.get('vault_uri'),
3128        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3081    def __init__(
3082        self,
3083        id=None,
3084        name=None,
3085        tags=None,
3086        vault_uri=None,
3087    ):
3088        self.id = id if id is not None else ''
3089        '''
3090         Unique identifier of the SecretStore.
3091        '''
3092        self.name = name if name is not None else ''
3093        '''
3094         Unique human-readable name of the SecretStore.
3095        '''
3096        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3097        '''
3098         Tags is a map of key, value pairs.
3099        '''
3100        self.vault_uri = vault_uri if vault_uri is not None else ''
3101        '''
3102
3103        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3113    def to_dict(self):
3114        return {
3115            'id': self.id,
3116            'name': self.name,
3117            'tags': self.tags,
3118            'vault_uri': self.vault_uri,
3119        }
@classmethod
def from_dict(cls, d)
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            id=d.get('id'),
3125            name=d.get('name'),
3126            tags=d.get('tags'),
3127            vault_uri=d.get('vault_uri'),
3128        )
class BigQuery:
3131class BigQuery:
3132    '''
3133
3134    '''
3135    __slots__ = [
3136        'bind_interface',
3137        'egress_filter',
3138        'endpoint',
3139        'healthy',
3140        'id',
3141        'name',
3142        'port_override',
3143        'private_key',
3144        'project',
3145        'secret_store_id',
3146        'tags',
3147        'username',
3148    ]
3149
3150    def __init__(
3151        self,
3152        bind_interface=None,
3153        egress_filter=None,
3154        endpoint=None,
3155        healthy=None,
3156        id=None,
3157        name=None,
3158        port_override=None,
3159        private_key=None,
3160        project=None,
3161        secret_store_id=None,
3162        tags=None,
3163        username=None,
3164    ):
3165        self.bind_interface = bind_interface if bind_interface is not None else ''
3166        '''
3167         Bind interface
3168        '''
3169        self.egress_filter = egress_filter if egress_filter is not None else ''
3170        '''
3171         A filter applied to the routing logic to pin datasource to nodes.
3172        '''
3173        self.endpoint = endpoint if endpoint is not None else ''
3174        '''
3175
3176        '''
3177        self.healthy = healthy if healthy is not None else False
3178        '''
3179         True if the datasource is reachable and the credentials are valid.
3180        '''
3181        self.id = id if id is not None else ''
3182        '''
3183         Unique identifier of the Resource.
3184        '''
3185        self.name = name if name is not None else ''
3186        '''
3187         Unique human-readable name of the Resource.
3188        '''
3189        self.port_override = port_override if port_override is not None else 0
3190        '''
3191
3192        '''
3193        self.private_key = private_key if private_key is not None else ''
3194        '''
3195
3196        '''
3197        self.project = project if project is not None else ''
3198        '''
3199
3200        '''
3201        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3202        '''
3203         ID of the secret store containing credentials for this resource, if any.
3204        '''
3205        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3206        '''
3207         Tags is a map of key, value pairs.
3208        '''
3209        self.username = username if username is not None else ''
3210        '''
3211
3212        '''
3213
3214    def __repr__(self):
3215        return '<sdm.BigQuery ' + \
3216            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3217            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3218            'endpoint: ' + repr(self.endpoint) + ' ' +\
3219            'healthy: ' + repr(self.healthy) + ' ' +\
3220            'id: ' + repr(self.id) + ' ' +\
3221            'name: ' + repr(self.name) + ' ' +\
3222            'port_override: ' + repr(self.port_override) + ' ' +\
3223            'private_key: ' + repr(self.private_key) + ' ' +\
3224            'project: ' + repr(self.project) + ' ' +\
3225            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3226            'tags: ' + repr(self.tags) + ' ' +\
3227            'username: ' + repr(self.username) + ' ' +\
3228            '>'
3229
3230    def to_dict(self):
3231        return {
3232            'bind_interface': self.bind_interface,
3233            'egress_filter': self.egress_filter,
3234            'endpoint': self.endpoint,
3235            'healthy': self.healthy,
3236            'id': self.id,
3237            'name': self.name,
3238            'port_override': self.port_override,
3239            'private_key': self.private_key,
3240            'project': self.project,
3241            'secret_store_id': self.secret_store_id,
3242            'tags': self.tags,
3243            'username': self.username,
3244        }
3245
3246    @classmethod
3247    def from_dict(cls, d):
3248        return cls(
3249            bind_interface=d.get('bind_interface'),
3250            egress_filter=d.get('egress_filter'),
3251            endpoint=d.get('endpoint'),
3252            healthy=d.get('healthy'),
3253            id=d.get('id'),
3254            name=d.get('name'),
3255            port_override=d.get('port_override'),
3256            private_key=d.get('private_key'),
3257            project=d.get('project'),
3258            secret_store_id=d.get('secret_store_id'),
3259            tags=d.get('tags'),
3260            username=d.get('username'),
3261        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3150    def __init__(
3151        self,
3152        bind_interface=None,
3153        egress_filter=None,
3154        endpoint=None,
3155        healthy=None,
3156        id=None,
3157        name=None,
3158        port_override=None,
3159        private_key=None,
3160        project=None,
3161        secret_store_id=None,
3162        tags=None,
3163        username=None,
3164    ):
3165        self.bind_interface = bind_interface if bind_interface is not None else ''
3166        '''
3167         Bind interface
3168        '''
3169        self.egress_filter = egress_filter if egress_filter is not None else ''
3170        '''
3171         A filter applied to the routing logic to pin datasource to nodes.
3172        '''
3173        self.endpoint = endpoint if endpoint is not None else ''
3174        '''
3175
3176        '''
3177        self.healthy = healthy if healthy is not None else False
3178        '''
3179         True if the datasource is reachable and the credentials are valid.
3180        '''
3181        self.id = id if id is not None else ''
3182        '''
3183         Unique identifier of the Resource.
3184        '''
3185        self.name = name if name is not None else ''
3186        '''
3187         Unique human-readable name of the Resource.
3188        '''
3189        self.port_override = port_override if port_override is not None else 0
3190        '''
3191
3192        '''
3193        self.private_key = private_key if private_key is not None else ''
3194        '''
3195
3196        '''
3197        self.project = project if project is not None else ''
3198        '''
3199
3200        '''
3201        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3202        '''
3203         ID of the secret store containing credentials for this resource, if any.
3204        '''
3205        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3206        '''
3207         Tags is a map of key, value pairs.
3208        '''
3209        self.username = username if username is not None else ''
3210        '''
3211
3212        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3230    def to_dict(self):
3231        return {
3232            'bind_interface': self.bind_interface,
3233            'egress_filter': self.egress_filter,
3234            'endpoint': self.endpoint,
3235            'healthy': self.healthy,
3236            'id': self.id,
3237            'name': self.name,
3238            'port_override': self.port_override,
3239            'private_key': self.private_key,
3240            'project': self.project,
3241            'secret_store_id': self.secret_store_id,
3242            'tags': self.tags,
3243            'username': self.username,
3244        }
@classmethod
def from_dict(cls, d)
3246    @classmethod
3247    def from_dict(cls, d):
3248        return cls(
3249            bind_interface=d.get('bind_interface'),
3250            egress_filter=d.get('egress_filter'),
3251            endpoint=d.get('endpoint'),
3252            healthy=d.get('healthy'),
3253            id=d.get('id'),
3254            name=d.get('name'),
3255            port_override=d.get('port_override'),
3256            private_key=d.get('private_key'),
3257            project=d.get('project'),
3258            secret_store_id=d.get('secret_store_id'),
3259            tags=d.get('tags'),
3260            username=d.get('username'),
3261        )
class Cassandra:
3264class Cassandra:
3265    '''
3266
3267    '''
3268    __slots__ = [
3269        'bind_interface',
3270        'egress_filter',
3271        'healthy',
3272        'hostname',
3273        'id',
3274        'name',
3275        'password',
3276        'port',
3277        'port_override',
3278        'secret_store_id',
3279        'tags',
3280        'tls_required',
3281        'username',
3282    ]
3283
3284    def __init__(
3285        self,
3286        bind_interface=None,
3287        egress_filter=None,
3288        healthy=None,
3289        hostname=None,
3290        id=None,
3291        name=None,
3292        password=None,
3293        port=None,
3294        port_override=None,
3295        secret_store_id=None,
3296        tags=None,
3297        tls_required=None,
3298        username=None,
3299    ):
3300        self.bind_interface = bind_interface if bind_interface is not None else ''
3301        '''
3302         Bind interface
3303        '''
3304        self.egress_filter = egress_filter if egress_filter is not None else ''
3305        '''
3306         A filter applied to the routing logic to pin datasource to nodes.
3307        '''
3308        self.healthy = healthy if healthy is not None else False
3309        '''
3310         True if the datasource is reachable and the credentials are valid.
3311        '''
3312        self.hostname = hostname if hostname is not None else ''
3313        '''
3314
3315        '''
3316        self.id = id if id is not None else ''
3317        '''
3318         Unique identifier of the Resource.
3319        '''
3320        self.name = name if name is not None else ''
3321        '''
3322         Unique human-readable name of the Resource.
3323        '''
3324        self.password = password if password is not None else ''
3325        '''
3326
3327        '''
3328        self.port = port if port is not None else 0
3329        '''
3330
3331        '''
3332        self.port_override = port_override if port_override is not None else 0
3333        '''
3334
3335        '''
3336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3337        '''
3338         ID of the secret store containing credentials for this resource, if any.
3339        '''
3340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3341        '''
3342         Tags is a map of key, value pairs.
3343        '''
3344        self.tls_required = tls_required if tls_required is not None else False
3345        '''
3346
3347        '''
3348        self.username = username if username is not None else ''
3349        '''
3350
3351        '''
3352
3353    def __repr__(self):
3354        return '<sdm.Cassandra ' + \
3355            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3356            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3357            'healthy: ' + repr(self.healthy) + ' ' +\
3358            'hostname: ' + repr(self.hostname) + ' ' +\
3359            'id: ' + repr(self.id) + ' ' +\
3360            'name: ' + repr(self.name) + ' ' +\
3361            'password: ' + repr(self.password) + ' ' +\
3362            'port: ' + repr(self.port) + ' ' +\
3363            'port_override: ' + repr(self.port_override) + ' ' +\
3364            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3365            'tags: ' + repr(self.tags) + ' ' +\
3366            'tls_required: ' + repr(self.tls_required) + ' ' +\
3367            'username: ' + repr(self.username) + ' ' +\
3368            '>'
3369
3370    def to_dict(self):
3371        return {
3372            'bind_interface': self.bind_interface,
3373            'egress_filter': self.egress_filter,
3374            'healthy': self.healthy,
3375            'hostname': self.hostname,
3376            'id': self.id,
3377            'name': self.name,
3378            'password': self.password,
3379            'port': self.port,
3380            'port_override': self.port_override,
3381            'secret_store_id': self.secret_store_id,
3382            'tags': self.tags,
3383            'tls_required': self.tls_required,
3384            'username': self.username,
3385        }
3386
3387    @classmethod
3388    def from_dict(cls, d):
3389        return cls(
3390            bind_interface=d.get('bind_interface'),
3391            egress_filter=d.get('egress_filter'),
3392            healthy=d.get('healthy'),
3393            hostname=d.get('hostname'),
3394            id=d.get('id'),
3395            name=d.get('name'),
3396            password=d.get('password'),
3397            port=d.get('port'),
3398            port_override=d.get('port_override'),
3399            secret_store_id=d.get('secret_store_id'),
3400            tags=d.get('tags'),
3401            tls_required=d.get('tls_required'),
3402            username=d.get('username'),
3403        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3284    def __init__(
3285        self,
3286        bind_interface=None,
3287        egress_filter=None,
3288        healthy=None,
3289        hostname=None,
3290        id=None,
3291        name=None,
3292        password=None,
3293        port=None,
3294        port_override=None,
3295        secret_store_id=None,
3296        tags=None,
3297        tls_required=None,
3298        username=None,
3299    ):
3300        self.bind_interface = bind_interface if bind_interface is not None else ''
3301        '''
3302         Bind interface
3303        '''
3304        self.egress_filter = egress_filter if egress_filter is not None else ''
3305        '''
3306         A filter applied to the routing logic to pin datasource to nodes.
3307        '''
3308        self.healthy = healthy if healthy is not None else False
3309        '''
3310         True if the datasource is reachable and the credentials are valid.
3311        '''
3312        self.hostname = hostname if hostname is not None else ''
3313        '''
3314
3315        '''
3316        self.id = id if id is not None else ''
3317        '''
3318         Unique identifier of the Resource.
3319        '''
3320        self.name = name if name is not None else ''
3321        '''
3322         Unique human-readable name of the Resource.
3323        '''
3324        self.password = password if password is not None else ''
3325        '''
3326
3327        '''
3328        self.port = port if port is not None else 0
3329        '''
3330
3331        '''
3332        self.port_override = port_override if port_override is not None else 0
3333        '''
3334
3335        '''
3336        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3337        '''
3338         ID of the secret store containing credentials for this resource, if any.
3339        '''
3340        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3341        '''
3342         Tags is a map of key, value pairs.
3343        '''
3344        self.tls_required = tls_required if tls_required is not None else False
3345        '''
3346
3347        '''
3348        self.username = username if username is not None else ''
3349        '''
3350
3351        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3370    def to_dict(self):
3371        return {
3372            'bind_interface': self.bind_interface,
3373            'egress_filter': self.egress_filter,
3374            'healthy': self.healthy,
3375            'hostname': self.hostname,
3376            'id': self.id,
3377            'name': self.name,
3378            'password': self.password,
3379            'port': self.port,
3380            'port_override': self.port_override,
3381            'secret_store_id': self.secret_store_id,
3382            'tags': self.tags,
3383            'tls_required': self.tls_required,
3384            'username': self.username,
3385        }
@classmethod
def from_dict(cls, d)
3387    @classmethod
3388    def from_dict(cls, d):
3389        return cls(
3390            bind_interface=d.get('bind_interface'),
3391            egress_filter=d.get('egress_filter'),
3392            healthy=d.get('healthy'),
3393            hostname=d.get('hostname'),
3394            id=d.get('id'),
3395            name=d.get('name'),
3396            password=d.get('password'),
3397            port=d.get('port'),
3398            port_override=d.get('port_override'),
3399            secret_store_id=d.get('secret_store_id'),
3400            tags=d.get('tags'),
3401            tls_required=d.get('tls_required'),
3402            username=d.get('username'),
3403        )
class Citus:
3406class Citus:
3407    '''
3408
3409    '''
3410    __slots__ = [
3411        'bind_interface',
3412        'database',
3413        'egress_filter',
3414        'healthy',
3415        'hostname',
3416        'id',
3417        'name',
3418        'override_database',
3419        'password',
3420        'port',
3421        'port_override',
3422        'secret_store_id',
3423        'tags',
3424        'username',
3425    ]
3426
3427    def __init__(
3428        self,
3429        bind_interface=None,
3430        database=None,
3431        egress_filter=None,
3432        healthy=None,
3433        hostname=None,
3434        id=None,
3435        name=None,
3436        override_database=None,
3437        password=None,
3438        port=None,
3439        port_override=None,
3440        secret_store_id=None,
3441        tags=None,
3442        username=None,
3443    ):
3444        self.bind_interface = bind_interface if bind_interface is not None else ''
3445        '''
3446         Bind interface
3447        '''
3448        self.database = database if database is not None else ''
3449        '''
3450
3451        '''
3452        self.egress_filter = egress_filter if egress_filter is not None else ''
3453        '''
3454         A filter applied to the routing logic to pin datasource to nodes.
3455        '''
3456        self.healthy = healthy if healthy is not None else False
3457        '''
3458         True if the datasource is reachable and the credentials are valid.
3459        '''
3460        self.hostname = hostname if hostname is not None else ''
3461        '''
3462
3463        '''
3464        self.id = id if id is not None else ''
3465        '''
3466         Unique identifier of the Resource.
3467        '''
3468        self.name = name if name is not None else ''
3469        '''
3470         Unique human-readable name of the Resource.
3471        '''
3472        self.override_database = override_database if override_database is not None else False
3473        '''
3474
3475        '''
3476        self.password = password if password is not None else ''
3477        '''
3478
3479        '''
3480        self.port = port if port is not None else 0
3481        '''
3482
3483        '''
3484        self.port_override = port_override if port_override is not None else 0
3485        '''
3486
3487        '''
3488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3489        '''
3490         ID of the secret store containing credentials for this resource, if any.
3491        '''
3492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3493        '''
3494         Tags is a map of key, value pairs.
3495        '''
3496        self.username = username if username is not None else ''
3497        '''
3498
3499        '''
3500
3501    def __repr__(self):
3502        return '<sdm.Citus ' + \
3503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3504            'database: ' + repr(self.database) + ' ' +\
3505            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3506            'healthy: ' + repr(self.healthy) + ' ' +\
3507            'hostname: ' + repr(self.hostname) + ' ' +\
3508            'id: ' + repr(self.id) + ' ' +\
3509            'name: ' + repr(self.name) + ' ' +\
3510            'override_database: ' + repr(self.override_database) + ' ' +\
3511            'password: ' + repr(self.password) + ' ' +\
3512            'port: ' + repr(self.port) + ' ' +\
3513            'port_override: ' + repr(self.port_override) + ' ' +\
3514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3515            'tags: ' + repr(self.tags) + ' ' +\
3516            'username: ' + repr(self.username) + ' ' +\
3517            '>'
3518
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'override_database': self.override_database,
3529            'password': self.password,
3530            'port': self.port,
3531            'port_override': self.port_override,
3532            'secret_store_id': self.secret_store_id,
3533            'tags': self.tags,
3534            'username': self.username,
3535        }
3536
3537    @classmethod
3538    def from_dict(cls, d):
3539        return cls(
3540            bind_interface=d.get('bind_interface'),
3541            database=d.get('database'),
3542            egress_filter=d.get('egress_filter'),
3543            healthy=d.get('healthy'),
3544            hostname=d.get('hostname'),
3545            id=d.get('id'),
3546            name=d.get('name'),
3547            override_database=d.get('override_database'),
3548            password=d.get('password'),
3549            port=d.get('port'),
3550            port_override=d.get('port_override'),
3551            secret_store_id=d.get('secret_store_id'),
3552            tags=d.get('tags'),
3553            username=d.get('username'),
3554        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3427    def __init__(
3428        self,
3429        bind_interface=None,
3430        database=None,
3431        egress_filter=None,
3432        healthy=None,
3433        hostname=None,
3434        id=None,
3435        name=None,
3436        override_database=None,
3437        password=None,
3438        port=None,
3439        port_override=None,
3440        secret_store_id=None,
3441        tags=None,
3442        username=None,
3443    ):
3444        self.bind_interface = bind_interface if bind_interface is not None else ''
3445        '''
3446         Bind interface
3447        '''
3448        self.database = database if database is not None else ''
3449        '''
3450
3451        '''
3452        self.egress_filter = egress_filter if egress_filter is not None else ''
3453        '''
3454         A filter applied to the routing logic to pin datasource to nodes.
3455        '''
3456        self.healthy = healthy if healthy is not None else False
3457        '''
3458         True if the datasource is reachable and the credentials are valid.
3459        '''
3460        self.hostname = hostname if hostname is not None else ''
3461        '''
3462
3463        '''
3464        self.id = id if id is not None else ''
3465        '''
3466         Unique identifier of the Resource.
3467        '''
3468        self.name = name if name is not None else ''
3469        '''
3470         Unique human-readable name of the Resource.
3471        '''
3472        self.override_database = override_database if override_database is not None else False
3473        '''
3474
3475        '''
3476        self.password = password if password is not None else ''
3477        '''
3478
3479        '''
3480        self.port = port if port is not None else 0
3481        '''
3482
3483        '''
3484        self.port_override = port_override if port_override is not None else 0
3485        '''
3486
3487        '''
3488        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3489        '''
3490         ID of the secret store containing credentials for this resource, if any.
3491        '''
3492        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3493        '''
3494         Tags is a map of key, value pairs.
3495        '''
3496        self.username = username if username is not None else ''
3497        '''
3498
3499        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3519    def to_dict(self):
3520        return {
3521            'bind_interface': self.bind_interface,
3522            'database': self.database,
3523            'egress_filter': self.egress_filter,
3524            'healthy': self.healthy,
3525            'hostname': self.hostname,
3526            'id': self.id,
3527            'name': self.name,
3528            'override_database': self.override_database,
3529            'password': self.password,
3530            'port': self.port,
3531            'port_override': self.port_override,
3532            'secret_store_id': self.secret_store_id,
3533            'tags': self.tags,
3534            'username': self.username,
3535        }
@classmethod
def from_dict(cls, d)
3537    @classmethod
3538    def from_dict(cls, d):
3539        return cls(
3540            bind_interface=d.get('bind_interface'),
3541            database=d.get('database'),
3542            egress_filter=d.get('egress_filter'),
3543            healthy=d.get('healthy'),
3544            hostname=d.get('hostname'),
3545            id=d.get('id'),
3546            name=d.get('name'),
3547            override_database=d.get('override_database'),
3548            password=d.get('password'),
3549            port=d.get('port'),
3550            port_override=d.get('port_override'),
3551            secret_store_id=d.get('secret_store_id'),
3552            tags=d.get('tags'),
3553            username=d.get('username'),
3554        )
class Clustrix:
3557class Clustrix:
3558    '''
3559
3560    '''
3561    __slots__ = [
3562        'bind_interface',
3563        'database',
3564        'egress_filter',
3565        'healthy',
3566        'hostname',
3567        'id',
3568        'name',
3569        'password',
3570        'port',
3571        'port_override',
3572        'secret_store_id',
3573        'tags',
3574        'username',
3575    ]
3576
3577    def __init__(
3578        self,
3579        bind_interface=None,
3580        database=None,
3581        egress_filter=None,
3582        healthy=None,
3583        hostname=None,
3584        id=None,
3585        name=None,
3586        password=None,
3587        port=None,
3588        port_override=None,
3589        secret_store_id=None,
3590        tags=None,
3591        username=None,
3592    ):
3593        self.bind_interface = bind_interface if bind_interface is not None else ''
3594        '''
3595         Bind interface
3596        '''
3597        self.database = database if database is not None else ''
3598        '''
3599
3600        '''
3601        self.egress_filter = egress_filter if egress_filter is not None else ''
3602        '''
3603         A filter applied to the routing logic to pin datasource to nodes.
3604        '''
3605        self.healthy = healthy if healthy is not None else False
3606        '''
3607         True if the datasource is reachable and the credentials are valid.
3608        '''
3609        self.hostname = hostname if hostname is not None else ''
3610        '''
3611
3612        '''
3613        self.id = id if id is not None else ''
3614        '''
3615         Unique identifier of the Resource.
3616        '''
3617        self.name = name if name is not None else ''
3618        '''
3619         Unique human-readable name of the Resource.
3620        '''
3621        self.password = password if password is not None else ''
3622        '''
3623
3624        '''
3625        self.port = port if port is not None else 0
3626        '''
3627
3628        '''
3629        self.port_override = port_override if port_override is not None else 0
3630        '''
3631
3632        '''
3633        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3634        '''
3635         ID of the secret store containing credentials for this resource, if any.
3636        '''
3637        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3638        '''
3639         Tags is a map of key, value pairs.
3640        '''
3641        self.username = username if username is not None else ''
3642        '''
3643
3644        '''
3645
3646    def __repr__(self):
3647        return '<sdm.Clustrix ' + \
3648            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3649            'database: ' + repr(self.database) + ' ' +\
3650            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3651            'healthy: ' + repr(self.healthy) + ' ' +\
3652            'hostname: ' + repr(self.hostname) + ' ' +\
3653            'id: ' + repr(self.id) + ' ' +\
3654            'name: ' + repr(self.name) + ' ' +\
3655            'password: ' + repr(self.password) + ' ' +\
3656            'port: ' + repr(self.port) + ' ' +\
3657            'port_override: ' + repr(self.port_override) + ' ' +\
3658            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3659            'tags: ' + repr(self.tags) + ' ' +\
3660            'username: ' + repr(self.username) + ' ' +\
3661            '>'
3662
3663    def to_dict(self):
3664        return {
3665            'bind_interface': self.bind_interface,
3666            'database': self.database,
3667            'egress_filter': self.egress_filter,
3668            'healthy': self.healthy,
3669            'hostname': self.hostname,
3670            'id': self.id,
3671            'name': self.name,
3672            'password': self.password,
3673            'port': self.port,
3674            'port_override': self.port_override,
3675            'secret_store_id': self.secret_store_id,
3676            'tags': self.tags,
3677            'username': self.username,
3678        }
3679
3680    @classmethod
3681    def from_dict(cls, d):
3682        return cls(
3683            bind_interface=d.get('bind_interface'),
3684            database=d.get('database'),
3685            egress_filter=d.get('egress_filter'),
3686            healthy=d.get('healthy'),
3687            hostname=d.get('hostname'),
3688            id=d.get('id'),
3689            name=d.get('name'),
3690            password=d.get('password'),
3691            port=d.get('port'),
3692            port_override=d.get('port_override'),
3693            secret_store_id=d.get('secret_store_id'),
3694            tags=d.get('tags'),
3695            username=d.get('username'),
3696        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3577    def __init__(
3578        self,
3579        bind_interface=None,
3580        database=None,
3581        egress_filter=None,
3582        healthy=None,
3583        hostname=None,
3584        id=None,
3585        name=None,
3586        password=None,
3587        port=None,
3588        port_override=None,
3589        secret_store_id=None,
3590        tags=None,
3591        username=None,
3592    ):
3593        self.bind_interface = bind_interface if bind_interface is not None else ''
3594        '''
3595         Bind interface
3596        '''
3597        self.database = database if database is not None else ''
3598        '''
3599
3600        '''
3601        self.egress_filter = egress_filter if egress_filter is not None else ''
3602        '''
3603         A filter applied to the routing logic to pin datasource to nodes.
3604        '''
3605        self.healthy = healthy if healthy is not None else False
3606        '''
3607         True if the datasource is reachable and the credentials are valid.
3608        '''
3609        self.hostname = hostname if hostname is not None else ''
3610        '''
3611
3612        '''
3613        self.id = id if id is not None else ''
3614        '''
3615         Unique identifier of the Resource.
3616        '''
3617        self.name = name if name is not None else ''
3618        '''
3619         Unique human-readable name of the Resource.
3620        '''
3621        self.password = password if password is not None else ''
3622        '''
3623
3624        '''
3625        self.port = port if port is not None else 0
3626        '''
3627
3628        '''
3629        self.port_override = port_override if port_override is not None else 0
3630        '''
3631
3632        '''
3633        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3634        '''
3635         ID of the secret store containing credentials for this resource, if any.
3636        '''
3637        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3638        '''
3639         Tags is a map of key, value pairs.
3640        '''
3641        self.username = username if username is not None else ''
3642        '''
3643
3644        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3663    def to_dict(self):
3664        return {
3665            'bind_interface': self.bind_interface,
3666            'database': self.database,
3667            'egress_filter': self.egress_filter,
3668            'healthy': self.healthy,
3669            'hostname': self.hostname,
3670            'id': self.id,
3671            'name': self.name,
3672            'password': self.password,
3673            'port': self.port,
3674            'port_override': self.port_override,
3675            'secret_store_id': self.secret_store_id,
3676            'tags': self.tags,
3677            'username': self.username,
3678        }
@classmethod
def from_dict(cls, d)
3680    @classmethod
3681    def from_dict(cls, d):
3682        return cls(
3683            bind_interface=d.get('bind_interface'),
3684            database=d.get('database'),
3685            egress_filter=d.get('egress_filter'),
3686            healthy=d.get('healthy'),
3687            hostname=d.get('hostname'),
3688            id=d.get('id'),
3689            name=d.get('name'),
3690            password=d.get('password'),
3691            port=d.get('port'),
3692            port_override=d.get('port_override'),
3693            secret_store_id=d.get('secret_store_id'),
3694            tags=d.get('tags'),
3695            username=d.get('username'),
3696        )
class Cockroach:
3699class Cockroach:
3700    '''
3701
3702    '''
3703    __slots__ = [
3704        'bind_interface',
3705        'database',
3706        'egress_filter',
3707        'healthy',
3708        'hostname',
3709        'id',
3710        'name',
3711        'override_database',
3712        'password',
3713        'port',
3714        'port_override',
3715        'secret_store_id',
3716        'tags',
3717        'username',
3718    ]
3719
3720    def __init__(
3721        self,
3722        bind_interface=None,
3723        database=None,
3724        egress_filter=None,
3725        healthy=None,
3726        hostname=None,
3727        id=None,
3728        name=None,
3729        override_database=None,
3730        password=None,
3731        port=None,
3732        port_override=None,
3733        secret_store_id=None,
3734        tags=None,
3735        username=None,
3736    ):
3737        self.bind_interface = bind_interface if bind_interface is not None else ''
3738        '''
3739         Bind interface
3740        '''
3741        self.database = database if database is not None else ''
3742        '''
3743
3744        '''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        '''
3755
3756        '''
3757        self.id = id if id is not None else ''
3758        '''
3759         Unique identifier of the Resource.
3760        '''
3761        self.name = name if name is not None else ''
3762        '''
3763         Unique human-readable name of the Resource.
3764        '''
3765        self.override_database = override_database if override_database is not None else False
3766        '''
3767
3768        '''
3769        self.password = password if password is not None else ''
3770        '''
3771
3772        '''
3773        self.port = port if port is not None else 0
3774        '''
3775
3776        '''
3777        self.port_override = port_override if port_override is not None else 0
3778        '''
3779
3780        '''
3781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3782        '''
3783         ID of the secret store containing credentials for this resource, if any.
3784        '''
3785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3786        '''
3787         Tags is a map of key, value pairs.
3788        '''
3789        self.username = username if username is not None else ''
3790        '''
3791
3792        '''
3793
3794    def __repr__(self):
3795        return '<sdm.Cockroach ' + \
3796            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3797            'database: ' + repr(self.database) + ' ' +\
3798            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3799            'healthy: ' + repr(self.healthy) + ' ' +\
3800            'hostname: ' + repr(self.hostname) + ' ' +\
3801            'id: ' + repr(self.id) + ' ' +\
3802            'name: ' + repr(self.name) + ' ' +\
3803            'override_database: ' + repr(self.override_database) + ' ' +\
3804            'password: ' + repr(self.password) + ' ' +\
3805            'port: ' + repr(self.port) + ' ' +\
3806            'port_override: ' + repr(self.port_override) + ' ' +\
3807            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3808            'tags: ' + repr(self.tags) + ' ' +\
3809            'username: ' + repr(self.username) + ' ' +\
3810            '>'
3811
3812    def to_dict(self):
3813        return {
3814            'bind_interface': self.bind_interface,
3815            'database': self.database,
3816            'egress_filter': self.egress_filter,
3817            'healthy': self.healthy,
3818            'hostname': self.hostname,
3819            'id': self.id,
3820            'name': self.name,
3821            'override_database': self.override_database,
3822            'password': self.password,
3823            'port': self.port,
3824            'port_override': self.port_override,
3825            'secret_store_id': self.secret_store_id,
3826            'tags': self.tags,
3827            'username': self.username,
3828        }
3829
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls(
3833            bind_interface=d.get('bind_interface'),
3834            database=d.get('database'),
3835            egress_filter=d.get('egress_filter'),
3836            healthy=d.get('healthy'),
3837            hostname=d.get('hostname'),
3838            id=d.get('id'),
3839            name=d.get('name'),
3840            override_database=d.get('override_database'),
3841            password=d.get('password'),
3842            port=d.get('port'),
3843            port_override=d.get('port_override'),
3844            secret_store_id=d.get('secret_store_id'),
3845            tags=d.get('tags'),
3846            username=d.get('username'),
3847        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3720    def __init__(
3721        self,
3722        bind_interface=None,
3723        database=None,
3724        egress_filter=None,
3725        healthy=None,
3726        hostname=None,
3727        id=None,
3728        name=None,
3729        override_database=None,
3730        password=None,
3731        port=None,
3732        port_override=None,
3733        secret_store_id=None,
3734        tags=None,
3735        username=None,
3736    ):
3737        self.bind_interface = bind_interface if bind_interface is not None else ''
3738        '''
3739         Bind interface
3740        '''
3741        self.database = database if database is not None else ''
3742        '''
3743
3744        '''
3745        self.egress_filter = egress_filter if egress_filter is not None else ''
3746        '''
3747         A filter applied to the routing logic to pin datasource to nodes.
3748        '''
3749        self.healthy = healthy if healthy is not None else False
3750        '''
3751         True if the datasource is reachable and the credentials are valid.
3752        '''
3753        self.hostname = hostname if hostname is not None else ''
3754        '''
3755
3756        '''
3757        self.id = id if id is not None else ''
3758        '''
3759         Unique identifier of the Resource.
3760        '''
3761        self.name = name if name is not None else ''
3762        '''
3763         Unique human-readable name of the Resource.
3764        '''
3765        self.override_database = override_database if override_database is not None else False
3766        '''
3767
3768        '''
3769        self.password = password if password is not None else ''
3770        '''
3771
3772        '''
3773        self.port = port if port is not None else 0
3774        '''
3775
3776        '''
3777        self.port_override = port_override if port_override is not None else 0
3778        '''
3779
3780        '''
3781        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3782        '''
3783         ID of the secret store containing credentials for this resource, if any.
3784        '''
3785        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3786        '''
3787         Tags is a map of key, value pairs.
3788        '''
3789        self.username = username if username is not None else ''
3790        '''
3791
3792        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3812    def to_dict(self):
3813        return {
3814            'bind_interface': self.bind_interface,
3815            'database': self.database,
3816            'egress_filter': self.egress_filter,
3817            'healthy': self.healthy,
3818            'hostname': self.hostname,
3819            'id': self.id,
3820            'name': self.name,
3821            'override_database': self.override_database,
3822            'password': self.password,
3823            'port': self.port,
3824            'port_override': self.port_override,
3825            'secret_store_id': self.secret_store_id,
3826            'tags': self.tags,
3827            'username': self.username,
3828        }
@classmethod
def from_dict(cls, d)
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls(
3833            bind_interface=d.get('bind_interface'),
3834            database=d.get('database'),
3835            egress_filter=d.get('egress_filter'),
3836            healthy=d.get('healthy'),
3837            hostname=d.get('hostname'),
3838            id=d.get('id'),
3839            name=d.get('name'),
3840            override_database=d.get('override_database'),
3841            password=d.get('password'),
3842            port=d.get('port'),
3843            port_override=d.get('port_override'),
3844            secret_store_id=d.get('secret_store_id'),
3845            tags=d.get('tags'),
3846            username=d.get('username'),
3847        )
class ControlPanelGetSSHCAPublicKeyResponse:
3850class ControlPanelGetSSHCAPublicKeyResponse:
3851    '''
3852     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3853     organization's SSH Certificate Authority public key.
3854    '''
3855    __slots__ = [
3856        'meta',
3857        'public_key',
3858        'rate_limit',
3859    ]
3860
3861    def __init__(
3862        self,
3863        meta=None,
3864        public_key=None,
3865        rate_limit=None,
3866    ):
3867        self.meta = meta if meta is not None else None
3868        '''
3869         Reserved for future use.
3870        '''
3871        self.public_key = public_key if public_key is not None else ''
3872        '''
3873         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3874         key format.
3875        '''
3876        self.rate_limit = rate_limit if rate_limit is not None else None
3877        '''
3878         Rate limit information.
3879        '''
3880
3881    def __repr__(self):
3882        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3883            'meta: ' + repr(self.meta) + ' ' +\
3884            'public_key: ' + repr(self.public_key) + ' ' +\
3885            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3886            '>'
3887
3888    def to_dict(self):
3889        return {
3890            'meta': self.meta,
3891            'public_key': self.public_key,
3892            'rate_limit': self.rate_limit,
3893        }
3894
3895    @classmethod
3896    def from_dict(cls, d):
3897        return cls(
3898            meta=d.get('meta'),
3899            public_key=d.get('public_key'),
3900            rate_limit=d.get('rate_limit'),
3901        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3861    def __init__(
3862        self,
3863        meta=None,
3864        public_key=None,
3865        rate_limit=None,
3866    ):
3867        self.meta = meta if meta is not None else None
3868        '''
3869         Reserved for future use.
3870        '''
3871        self.public_key = public_key if public_key is not None else ''
3872        '''
3873         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3874         key format.
3875        '''
3876        self.rate_limit = rate_limit if rate_limit is not None else None
3877        '''
3878         Rate limit information.
3879        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3888    def to_dict(self):
3889        return {
3890            'meta': self.meta,
3891            'public_key': self.public_key,
3892            'rate_limit': self.rate_limit,
3893        }
@classmethod
def from_dict(cls, d)
3895    @classmethod
3896    def from_dict(cls, d):
3897        return cls(
3898            meta=d.get('meta'),
3899            public_key=d.get('public_key'),
3900            rate_limit=d.get('rate_limit'),
3901        )
class ControlPanelVerifyJWTResponse:
3904class ControlPanelVerifyJWTResponse:
3905    '''
3906     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3907    '''
3908    __slots__ = [
3909        'meta',
3910        'rate_limit',
3911        'valid',
3912    ]
3913
3914    def __init__(
3915        self,
3916        meta=None,
3917        rate_limit=None,
3918        valid=None,
3919    ):
3920        self.meta = meta if meta is not None else None
3921        '''
3922         Reserved for future use.
3923        '''
3924        self.rate_limit = rate_limit if rate_limit is not None else None
3925        '''
3926         Rate limit information.
3927        '''
3928        self.valid = valid if valid is not None else False
3929        '''
3930         Reports if the given token is valid.
3931        '''
3932
3933    def __repr__(self):
3934        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3935            'meta: ' + repr(self.meta) + ' ' +\
3936            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3937            'valid: ' + repr(self.valid) + ' ' +\
3938            '>'
3939
3940    def to_dict(self):
3941        return {
3942            'meta': self.meta,
3943            'rate_limit': self.rate_limit,
3944            'valid': self.valid,
3945        }
3946
3947    @classmethod
3948    def from_dict(cls, d):
3949        return cls(
3950            meta=d.get('meta'),
3951            rate_limit=d.get('rate_limit'),
3952            valid=d.get('valid'),
3953        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3914    def __init__(
3915        self,
3916        meta=None,
3917        rate_limit=None,
3918        valid=None,
3919    ):
3920        self.meta = meta if meta is not None else None
3921        '''
3922         Reserved for future use.
3923        '''
3924        self.rate_limit = rate_limit if rate_limit is not None else None
3925        '''
3926         Rate limit information.
3927        '''
3928        self.valid = valid if valid is not None else False
3929        '''
3930         Reports if the given token is valid.
3931        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3940    def to_dict(self):
3941        return {
3942            'meta': self.meta,
3943            'rate_limit': self.rate_limit,
3944            'valid': self.valid,
3945        }
@classmethod
def from_dict(cls, d)
3947    @classmethod
3948    def from_dict(cls, d):
3949        return cls(
3950            meta=d.get('meta'),
3951            rate_limit=d.get('rate_limit'),
3952            valid=d.get('valid'),
3953        )
class CreateResponseMetadata:
3956class CreateResponseMetadata:
3957    '''
3958     CreateResponseMetadata is reserved for future use.
3959    '''
3960    __slots__ = []
3961
3962    def __init__(self, ):
3963        pass
3964
3965    def __repr__(self):
3966        return '<sdm.CreateResponseMetadata ' + \
3967            '>'
3968
3969    def to_dict(self):
3970        return {}
3971
3972    @classmethod
3973    def from_dict(cls, d):
3974        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3962    def __init__(self, ):
3963        pass
def to_dict(self)
3969    def to_dict(self):
3970        return {}
@classmethod
def from_dict(cls, d)
3972    @classmethod
3973    def from_dict(cls, d):
3974        return cls()
class DB2I:
3977class DB2I:
3978    '''
3979
3980    '''
3981    __slots__ = [
3982        'bind_interface',
3983        'egress_filter',
3984        'healthy',
3985        'hostname',
3986        'id',
3987        'name',
3988        'password',
3989        'port',
3990        'port_override',
3991        'secret_store_id',
3992        'tags',
3993        'tls_required',
3994        'username',
3995    ]
3996
3997    def __init__(
3998        self,
3999        bind_interface=None,
4000        egress_filter=None,
4001        healthy=None,
4002        hostname=None,
4003        id=None,
4004        name=None,
4005        password=None,
4006        port=None,
4007        port_override=None,
4008        secret_store_id=None,
4009        tags=None,
4010        tls_required=None,
4011        username=None,
4012    ):
4013        self.bind_interface = bind_interface if bind_interface is not None else ''
4014        '''
4015         Bind interface
4016        '''
4017        self.egress_filter = egress_filter if egress_filter is not None else ''
4018        '''
4019         A filter applied to the routing logic to pin datasource to nodes.
4020        '''
4021        self.healthy = healthy if healthy is not None else False
4022        '''
4023         True if the datasource is reachable and the credentials are valid.
4024        '''
4025        self.hostname = hostname if hostname is not None else ''
4026        '''
4027
4028        '''
4029        self.id = id if id is not None else ''
4030        '''
4031         Unique identifier of the Resource.
4032        '''
4033        self.name = name if name is not None else ''
4034        '''
4035         Unique human-readable name of the Resource.
4036        '''
4037        self.password = password if password is not None else ''
4038        '''
4039
4040        '''
4041        self.port = port if port is not None else 0
4042        '''
4043
4044        '''
4045        self.port_override = port_override if port_override is not None else 0
4046        '''
4047
4048        '''
4049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4050        '''
4051         ID of the secret store containing credentials for this resource, if any.
4052        '''
4053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4054        '''
4055         Tags is a map of key, value pairs.
4056        '''
4057        self.tls_required = tls_required if tls_required is not None else False
4058        '''
4059
4060        '''
4061        self.username = username if username is not None else ''
4062        '''
4063
4064        '''
4065
4066    def __repr__(self):
4067        return '<sdm.DB2I ' + \
4068            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4069            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4070            'healthy: ' + repr(self.healthy) + ' ' +\
4071            'hostname: ' + repr(self.hostname) + ' ' +\
4072            'id: ' + repr(self.id) + ' ' +\
4073            'name: ' + repr(self.name) + ' ' +\
4074            'password: ' + repr(self.password) + ' ' +\
4075            'port: ' + repr(self.port) + ' ' +\
4076            'port_override: ' + repr(self.port_override) + ' ' +\
4077            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4078            'tags: ' + repr(self.tags) + ' ' +\
4079            'tls_required: ' + repr(self.tls_required) + ' ' +\
4080            'username: ' + repr(self.username) + ' ' +\
4081            '>'
4082
4083    def to_dict(self):
4084        return {
4085            'bind_interface': self.bind_interface,
4086            'egress_filter': self.egress_filter,
4087            'healthy': self.healthy,
4088            'hostname': self.hostname,
4089            'id': self.id,
4090            'name': self.name,
4091            'password': self.password,
4092            'port': self.port,
4093            'port_override': self.port_override,
4094            'secret_store_id': self.secret_store_id,
4095            'tags': self.tags,
4096            'tls_required': self.tls_required,
4097            'username': self.username,
4098        }
4099
4100    @classmethod
4101    def from_dict(cls, d):
4102        return cls(
4103            bind_interface=d.get('bind_interface'),
4104            egress_filter=d.get('egress_filter'),
4105            healthy=d.get('healthy'),
4106            hostname=d.get('hostname'),
4107            id=d.get('id'),
4108            name=d.get('name'),
4109            password=d.get('password'),
4110            port=d.get('port'),
4111            port_override=d.get('port_override'),
4112            secret_store_id=d.get('secret_store_id'),
4113            tags=d.get('tags'),
4114            tls_required=d.get('tls_required'),
4115            username=d.get('username'),
4116        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3997    def __init__(
3998        self,
3999        bind_interface=None,
4000        egress_filter=None,
4001        healthy=None,
4002        hostname=None,
4003        id=None,
4004        name=None,
4005        password=None,
4006        port=None,
4007        port_override=None,
4008        secret_store_id=None,
4009        tags=None,
4010        tls_required=None,
4011        username=None,
4012    ):
4013        self.bind_interface = bind_interface if bind_interface is not None else ''
4014        '''
4015         Bind interface
4016        '''
4017        self.egress_filter = egress_filter if egress_filter is not None else ''
4018        '''
4019         A filter applied to the routing logic to pin datasource to nodes.
4020        '''
4021        self.healthy = healthy if healthy is not None else False
4022        '''
4023         True if the datasource is reachable and the credentials are valid.
4024        '''
4025        self.hostname = hostname if hostname is not None else ''
4026        '''
4027
4028        '''
4029        self.id = id if id is not None else ''
4030        '''
4031         Unique identifier of the Resource.
4032        '''
4033        self.name = name if name is not None else ''
4034        '''
4035         Unique human-readable name of the Resource.
4036        '''
4037        self.password = password if password is not None else ''
4038        '''
4039
4040        '''
4041        self.port = port if port is not None else 0
4042        '''
4043
4044        '''
4045        self.port_override = port_override if port_override is not None else 0
4046        '''
4047
4048        '''
4049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4050        '''
4051         ID of the secret store containing credentials for this resource, if any.
4052        '''
4053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4054        '''
4055         Tags is a map of key, value pairs.
4056        '''
4057        self.tls_required = tls_required if tls_required is not None else False
4058        '''
4059
4060        '''
4061        self.username = username if username is not None else ''
4062        '''
4063
4064        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4083    def to_dict(self):
4084        return {
4085            'bind_interface': self.bind_interface,
4086            'egress_filter': self.egress_filter,
4087            'healthy': self.healthy,
4088            'hostname': self.hostname,
4089            'id': self.id,
4090            'name': self.name,
4091            'password': self.password,
4092            'port': self.port,
4093            'port_override': self.port_override,
4094            'secret_store_id': self.secret_store_id,
4095            'tags': self.tags,
4096            'tls_required': self.tls_required,
4097            'username': self.username,
4098        }
@classmethod
def from_dict(cls, d)
4100    @classmethod
4101    def from_dict(cls, d):
4102        return cls(
4103            bind_interface=d.get('bind_interface'),
4104            egress_filter=d.get('egress_filter'),
4105            healthy=d.get('healthy'),
4106            hostname=d.get('hostname'),
4107            id=d.get('id'),
4108            name=d.get('name'),
4109            password=d.get('password'),
4110            port=d.get('port'),
4111            port_override=d.get('port_override'),
4112            secret_store_id=d.get('secret_store_id'),
4113            tags=d.get('tags'),
4114            tls_required=d.get('tls_required'),
4115            username=d.get('username'),
4116        )
class DB2LUW:
4119class DB2LUW:
4120    '''
4121
4122    '''
4123    __slots__ = [
4124        'bind_interface',
4125        'database',
4126        'egress_filter',
4127        'healthy',
4128        'hostname',
4129        'id',
4130        'name',
4131        'password',
4132        'port',
4133        'port_override',
4134        'secret_store_id',
4135        'tags',
4136        'username',
4137    ]
4138
4139    def __init__(
4140        self,
4141        bind_interface=None,
4142        database=None,
4143        egress_filter=None,
4144        healthy=None,
4145        hostname=None,
4146        id=None,
4147        name=None,
4148        password=None,
4149        port=None,
4150        port_override=None,
4151        secret_store_id=None,
4152        tags=None,
4153        username=None,
4154    ):
4155        self.bind_interface = bind_interface if bind_interface is not None else ''
4156        '''
4157         Bind interface
4158        '''
4159        self.database = database if database is not None else ''
4160        '''
4161
4162        '''
4163        self.egress_filter = egress_filter if egress_filter is not None else ''
4164        '''
4165         A filter applied to the routing logic to pin datasource to nodes.
4166        '''
4167        self.healthy = healthy if healthy is not None else False
4168        '''
4169         True if the datasource is reachable and the credentials are valid.
4170        '''
4171        self.hostname = hostname if hostname is not None else ''
4172        '''
4173
4174        '''
4175        self.id = id if id is not None else ''
4176        '''
4177         Unique identifier of the Resource.
4178        '''
4179        self.name = name if name is not None else ''
4180        '''
4181         Unique human-readable name of the Resource.
4182        '''
4183        self.password = password if password is not None else ''
4184        '''
4185
4186        '''
4187        self.port = port if port is not None else 0
4188        '''
4189
4190        '''
4191        self.port_override = port_override if port_override is not None else 0
4192        '''
4193
4194        '''
4195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4196        '''
4197         ID of the secret store containing credentials for this resource, if any.
4198        '''
4199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4200        '''
4201         Tags is a map of key, value pairs.
4202        '''
4203        self.username = username if username is not None else ''
4204        '''
4205
4206        '''
4207
4208    def __repr__(self):
4209        return '<sdm.DB2LUW ' + \
4210            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4211            'database: ' + repr(self.database) + ' ' +\
4212            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4213            'healthy: ' + repr(self.healthy) + ' ' +\
4214            'hostname: ' + repr(self.hostname) + ' ' +\
4215            'id: ' + repr(self.id) + ' ' +\
4216            'name: ' + repr(self.name) + ' ' +\
4217            'password: ' + repr(self.password) + ' ' +\
4218            'port: ' + repr(self.port) + ' ' +\
4219            'port_override: ' + repr(self.port_override) + ' ' +\
4220            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4221            'tags: ' + repr(self.tags) + ' ' +\
4222            'username: ' + repr(self.username) + ' ' +\
4223            '>'
4224
4225    def to_dict(self):
4226        return {
4227            'bind_interface': self.bind_interface,
4228            'database': self.database,
4229            'egress_filter': self.egress_filter,
4230            'healthy': self.healthy,
4231            'hostname': self.hostname,
4232            'id': self.id,
4233            'name': self.name,
4234            'password': self.password,
4235            'port': self.port,
4236            'port_override': self.port_override,
4237            'secret_store_id': self.secret_store_id,
4238            'tags': self.tags,
4239            'username': self.username,
4240        }
4241
4242    @classmethod
4243    def from_dict(cls, d):
4244        return cls(
4245            bind_interface=d.get('bind_interface'),
4246            database=d.get('database'),
4247            egress_filter=d.get('egress_filter'),
4248            healthy=d.get('healthy'),
4249            hostname=d.get('hostname'),
4250            id=d.get('id'),
4251            name=d.get('name'),
4252            password=d.get('password'),
4253            port=d.get('port'),
4254            port_override=d.get('port_override'),
4255            secret_store_id=d.get('secret_store_id'),
4256            tags=d.get('tags'),
4257            username=d.get('username'),
4258        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4139    def __init__(
4140        self,
4141        bind_interface=None,
4142        database=None,
4143        egress_filter=None,
4144        healthy=None,
4145        hostname=None,
4146        id=None,
4147        name=None,
4148        password=None,
4149        port=None,
4150        port_override=None,
4151        secret_store_id=None,
4152        tags=None,
4153        username=None,
4154    ):
4155        self.bind_interface = bind_interface if bind_interface is not None else ''
4156        '''
4157         Bind interface
4158        '''
4159        self.database = database if database is not None else ''
4160        '''
4161
4162        '''
4163        self.egress_filter = egress_filter if egress_filter is not None else ''
4164        '''
4165         A filter applied to the routing logic to pin datasource to nodes.
4166        '''
4167        self.healthy = healthy if healthy is not None else False
4168        '''
4169         True if the datasource is reachable and the credentials are valid.
4170        '''
4171        self.hostname = hostname if hostname is not None else ''
4172        '''
4173
4174        '''
4175        self.id = id if id is not None else ''
4176        '''
4177         Unique identifier of the Resource.
4178        '''
4179        self.name = name if name is not None else ''
4180        '''
4181         Unique human-readable name of the Resource.
4182        '''
4183        self.password = password if password is not None else ''
4184        '''
4185
4186        '''
4187        self.port = port if port is not None else 0
4188        '''
4189
4190        '''
4191        self.port_override = port_override if port_override is not None else 0
4192        '''
4193
4194        '''
4195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4196        '''
4197         ID of the secret store containing credentials for this resource, if any.
4198        '''
4199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4200        '''
4201         Tags is a map of key, value pairs.
4202        '''
4203        self.username = username if username is not None else ''
4204        '''
4205
4206        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4225    def to_dict(self):
4226        return {
4227            'bind_interface': self.bind_interface,
4228            'database': self.database,
4229            'egress_filter': self.egress_filter,
4230            'healthy': self.healthy,
4231            'hostname': self.hostname,
4232            'id': self.id,
4233            'name': self.name,
4234            'password': self.password,
4235            'port': self.port,
4236            'port_override': self.port_override,
4237            'secret_store_id': self.secret_store_id,
4238            'tags': self.tags,
4239            'username': self.username,
4240        }
@classmethod
def from_dict(cls, d)
4242    @classmethod
4243    def from_dict(cls, d):
4244        return cls(
4245            bind_interface=d.get('bind_interface'),
4246            database=d.get('database'),
4247            egress_filter=d.get('egress_filter'),
4248            healthy=d.get('healthy'),
4249            hostname=d.get('hostname'),
4250            id=d.get('id'),
4251            name=d.get('name'),
4252            password=d.get('password'),
4253            port=d.get('port'),
4254            port_override=d.get('port_override'),
4255            secret_store_id=d.get('secret_store_id'),
4256            tags=d.get('tags'),
4257            username=d.get('username'),
4258        )
class DeleteResponseMetadata:
4261class DeleteResponseMetadata:
4262    '''
4263     DeleteResponseMetadata is reserved for future use.
4264    '''
4265    __slots__ = []
4266
4267    def __init__(self, ):
4268        pass
4269
4270    def __repr__(self):
4271        return '<sdm.DeleteResponseMetadata ' + \
4272            '>'
4273
4274    def to_dict(self):
4275        return {}
4276
4277    @classmethod
4278    def from_dict(cls, d):
4279        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4267    def __init__(self, ):
4268        pass
def to_dict(self)
4274    def to_dict(self):
4275        return {}
@classmethod
def from_dict(cls, d)
4277    @classmethod
4278    def from_dict(cls, d):
4279        return cls()
class DocumentDBHost:
4282class DocumentDBHost:
4283    '''
4284
4285    '''
4286    __slots__ = [
4287        'auth_database',
4288        'bind_interface',
4289        'egress_filter',
4290        'healthy',
4291        'hostname',
4292        'id',
4293        'name',
4294        'password',
4295        'port',
4296        'port_override',
4297        'secret_store_id',
4298        'tags',
4299        'username',
4300    ]
4301
4302    def __init__(
4303        self,
4304        auth_database=None,
4305        bind_interface=None,
4306        egress_filter=None,
4307        healthy=None,
4308        hostname=None,
4309        id=None,
4310        name=None,
4311        password=None,
4312        port=None,
4313        port_override=None,
4314        secret_store_id=None,
4315        tags=None,
4316        username=None,
4317    ):
4318        self.auth_database = auth_database if auth_database is not None else ''
4319        '''
4320
4321        '''
4322        self.bind_interface = bind_interface if bind_interface is not None else ''
4323        '''
4324         Bind interface
4325        '''
4326        self.egress_filter = egress_filter if egress_filter is not None else ''
4327        '''
4328         A filter applied to the routing logic to pin datasource to nodes.
4329        '''
4330        self.healthy = healthy if healthy is not None else False
4331        '''
4332         True if the datasource is reachable and the credentials are valid.
4333        '''
4334        self.hostname = hostname if hostname is not None else ''
4335        '''
4336
4337        '''
4338        self.id = id if id is not None else ''
4339        '''
4340         Unique identifier of the Resource.
4341        '''
4342        self.name = name if name is not None else ''
4343        '''
4344         Unique human-readable name of the Resource.
4345        '''
4346        self.password = password if password is not None else ''
4347        '''
4348
4349        '''
4350        self.port = port if port is not None else 0
4351        '''
4352
4353        '''
4354        self.port_override = port_override if port_override is not None else 0
4355        '''
4356
4357        '''
4358        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4359        '''
4360         ID of the secret store containing credentials for this resource, if any.
4361        '''
4362        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4363        '''
4364         Tags is a map of key, value pairs.
4365        '''
4366        self.username = username if username is not None else ''
4367        '''
4368
4369        '''
4370
4371    def __repr__(self):
4372        return '<sdm.DocumentDBHost ' + \
4373            'auth_database: ' + repr(self.auth_database) + ' ' +\
4374            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4375            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4376            'healthy: ' + repr(self.healthy) + ' ' +\
4377            'hostname: ' + repr(self.hostname) + ' ' +\
4378            'id: ' + repr(self.id) + ' ' +\
4379            'name: ' + repr(self.name) + ' ' +\
4380            'password: ' + repr(self.password) + ' ' +\
4381            'port: ' + repr(self.port) + ' ' +\
4382            'port_override: ' + repr(self.port_override) + ' ' +\
4383            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4384            'tags: ' + repr(self.tags) + ' ' +\
4385            'username: ' + repr(self.username) + ' ' +\
4386            '>'
4387
4388    def to_dict(self):
4389        return {
4390            'auth_database': self.auth_database,
4391            'bind_interface': self.bind_interface,
4392            'egress_filter': self.egress_filter,
4393            'healthy': self.healthy,
4394            'hostname': self.hostname,
4395            'id': self.id,
4396            'name': self.name,
4397            'password': self.password,
4398            'port': self.port,
4399            'port_override': self.port_override,
4400            'secret_store_id': self.secret_store_id,
4401            'tags': self.tags,
4402            'username': self.username,
4403        }
4404
4405    @classmethod
4406    def from_dict(cls, d):
4407        return cls(
4408            auth_database=d.get('auth_database'),
4409            bind_interface=d.get('bind_interface'),
4410            egress_filter=d.get('egress_filter'),
4411            healthy=d.get('healthy'),
4412            hostname=d.get('hostname'),
4413            id=d.get('id'),
4414            name=d.get('name'),
4415            password=d.get('password'),
4416            port=d.get('port'),
4417            port_override=d.get('port_override'),
4418            secret_store_id=d.get('secret_store_id'),
4419            tags=d.get('tags'),
4420            username=d.get('username'),
4421        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4302    def __init__(
4303        self,
4304        auth_database=None,
4305        bind_interface=None,
4306        egress_filter=None,
4307        healthy=None,
4308        hostname=None,
4309        id=None,
4310        name=None,
4311        password=None,
4312        port=None,
4313        port_override=None,
4314        secret_store_id=None,
4315        tags=None,
4316        username=None,
4317    ):
4318        self.auth_database = auth_database if auth_database is not None else ''
4319        '''
4320
4321        '''
4322        self.bind_interface = bind_interface if bind_interface is not None else ''
4323        '''
4324         Bind interface
4325        '''
4326        self.egress_filter = egress_filter if egress_filter is not None else ''
4327        '''
4328         A filter applied to the routing logic to pin datasource to nodes.
4329        '''
4330        self.healthy = healthy if healthy is not None else False
4331        '''
4332         True if the datasource is reachable and the credentials are valid.
4333        '''
4334        self.hostname = hostname if hostname is not None else ''
4335        '''
4336
4337        '''
4338        self.id = id if id is not None else ''
4339        '''
4340         Unique identifier of the Resource.
4341        '''
4342        self.name = name if name is not None else ''
4343        '''
4344         Unique human-readable name of the Resource.
4345        '''
4346        self.password = password if password is not None else ''
4347        '''
4348
4349        '''
4350        self.port = port if port is not None else 0
4351        '''
4352
4353        '''
4354        self.port_override = port_override if port_override is not None else 0
4355        '''
4356
4357        '''
4358        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4359        '''
4360         ID of the secret store containing credentials for this resource, if any.
4361        '''
4362        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4363        '''
4364         Tags is a map of key, value pairs.
4365        '''
4366        self.username = username if username is not None else ''
4367        '''
4368
4369        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4388    def to_dict(self):
4389        return {
4390            'auth_database': self.auth_database,
4391            'bind_interface': self.bind_interface,
4392            'egress_filter': self.egress_filter,
4393            'healthy': self.healthy,
4394            'hostname': self.hostname,
4395            'id': self.id,
4396            'name': self.name,
4397            'password': self.password,
4398            'port': self.port,
4399            'port_override': self.port_override,
4400            'secret_store_id': self.secret_store_id,
4401            'tags': self.tags,
4402            'username': self.username,
4403        }
@classmethod
def from_dict(cls, d)
4405    @classmethod
4406    def from_dict(cls, d):
4407        return cls(
4408            auth_database=d.get('auth_database'),
4409            bind_interface=d.get('bind_interface'),
4410            egress_filter=d.get('egress_filter'),
4411            healthy=d.get('healthy'),
4412            hostname=d.get('hostname'),
4413            id=d.get('id'),
4414            name=d.get('name'),
4415            password=d.get('password'),
4416            port=d.get('port'),
4417            port_override=d.get('port_override'),
4418            secret_store_id=d.get('secret_store_id'),
4419            tags=d.get('tags'),
4420            username=d.get('username'),
4421        )
class DocumentDBReplicaSet:
4424class DocumentDBReplicaSet:
4425    '''
4426
4427    '''
4428    __slots__ = [
4429        'auth_database',
4430        'bind_interface',
4431        'connect_to_replica',
4432        'egress_filter',
4433        'healthy',
4434        'hostname',
4435        'id',
4436        'name',
4437        'password',
4438        'port_override',
4439        'replica_set',
4440        'secret_store_id',
4441        'tags',
4442        'username',
4443    ]
4444
4445    def __init__(
4446        self,
4447        auth_database=None,
4448        bind_interface=None,
4449        connect_to_replica=None,
4450        egress_filter=None,
4451        healthy=None,
4452        hostname=None,
4453        id=None,
4454        name=None,
4455        password=None,
4456        port_override=None,
4457        replica_set=None,
4458        secret_store_id=None,
4459        tags=None,
4460        username=None,
4461    ):
4462        self.auth_database = auth_database if auth_database is not None else ''
4463        '''
4464
4465        '''
4466        self.bind_interface = bind_interface if bind_interface is not None else ''
4467        '''
4468         Bind interface
4469        '''
4470        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4471        '''
4472
4473        '''
4474        self.egress_filter = egress_filter if egress_filter is not None else ''
4475        '''
4476         A filter applied to the routing logic to pin datasource to nodes.
4477        '''
4478        self.healthy = healthy if healthy is not None else False
4479        '''
4480         True if the datasource is reachable and the credentials are valid.
4481        '''
4482        self.hostname = hostname if hostname is not None else ''
4483        '''
4484         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4485        '''
4486        self.id = id if id is not None else ''
4487        '''
4488         Unique identifier of the Resource.
4489        '''
4490        self.name = name if name is not None else ''
4491        '''
4492         Unique human-readable name of the Resource.
4493        '''
4494        self.password = password if password is not None else ''
4495        '''
4496
4497        '''
4498        self.port_override = port_override if port_override is not None else 0
4499        '''
4500
4501        '''
4502        self.replica_set = replica_set if replica_set is not None else ''
4503        '''
4504
4505        '''
4506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4507        '''
4508         ID of the secret store containing credentials for this resource, if any.
4509        '''
4510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4511        '''
4512         Tags is a map of key, value pairs.
4513        '''
4514        self.username = username if username is not None else ''
4515        '''
4516
4517        '''
4518
4519    def __repr__(self):
4520        return '<sdm.DocumentDBReplicaSet ' + \
4521            'auth_database: ' + repr(self.auth_database) + ' ' +\
4522            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4523            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4524            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4525            'healthy: ' + repr(self.healthy) + ' ' +\
4526            'hostname: ' + repr(self.hostname) + ' ' +\
4527            'id: ' + repr(self.id) + ' ' +\
4528            'name: ' + repr(self.name) + ' ' +\
4529            'password: ' + repr(self.password) + ' ' +\
4530            'port_override: ' + repr(self.port_override) + ' ' +\
4531            'replica_set: ' + repr(self.replica_set) + ' ' +\
4532            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4533            'tags: ' + repr(self.tags) + ' ' +\
4534            'username: ' + repr(self.username) + ' ' +\
4535            '>'
4536
4537    def to_dict(self):
4538        return {
4539            'auth_database': self.auth_database,
4540            'bind_interface': self.bind_interface,
4541            'connect_to_replica': self.connect_to_replica,
4542            'egress_filter': self.egress_filter,
4543            'healthy': self.healthy,
4544            'hostname': self.hostname,
4545            'id': self.id,
4546            'name': self.name,
4547            'password': self.password,
4548            'port_override': self.port_override,
4549            'replica_set': self.replica_set,
4550            'secret_store_id': self.secret_store_id,
4551            'tags': self.tags,
4552            'username': self.username,
4553        }
4554
4555    @classmethod
4556    def from_dict(cls, d):
4557        return cls(
4558            auth_database=d.get('auth_database'),
4559            bind_interface=d.get('bind_interface'),
4560            connect_to_replica=d.get('connect_to_replica'),
4561            egress_filter=d.get('egress_filter'),
4562            healthy=d.get('healthy'),
4563            hostname=d.get('hostname'),
4564            id=d.get('id'),
4565            name=d.get('name'),
4566            password=d.get('password'),
4567            port_override=d.get('port_override'),
4568            replica_set=d.get('replica_set'),
4569            secret_store_id=d.get('secret_store_id'),
4570            tags=d.get('tags'),
4571            username=d.get('username'),
4572        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4445    def __init__(
4446        self,
4447        auth_database=None,
4448        bind_interface=None,
4449        connect_to_replica=None,
4450        egress_filter=None,
4451        healthy=None,
4452        hostname=None,
4453        id=None,
4454        name=None,
4455        password=None,
4456        port_override=None,
4457        replica_set=None,
4458        secret_store_id=None,
4459        tags=None,
4460        username=None,
4461    ):
4462        self.auth_database = auth_database if auth_database is not None else ''
4463        '''
4464
4465        '''
4466        self.bind_interface = bind_interface if bind_interface is not None else ''
4467        '''
4468         Bind interface
4469        '''
4470        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4471        '''
4472
4473        '''
4474        self.egress_filter = egress_filter if egress_filter is not None else ''
4475        '''
4476         A filter applied to the routing logic to pin datasource to nodes.
4477        '''
4478        self.healthy = healthy if healthy is not None else False
4479        '''
4480         True if the datasource is reachable and the credentials are valid.
4481        '''
4482        self.hostname = hostname if hostname is not None else ''
4483        '''
4484         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4485        '''
4486        self.id = id if id is not None else ''
4487        '''
4488         Unique identifier of the Resource.
4489        '''
4490        self.name = name if name is not None else ''
4491        '''
4492         Unique human-readable name of the Resource.
4493        '''
4494        self.password = password if password is not None else ''
4495        '''
4496
4497        '''
4498        self.port_override = port_override if port_override is not None else 0
4499        '''
4500
4501        '''
4502        self.replica_set = replica_set if replica_set is not None else ''
4503        '''
4504
4505        '''
4506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4507        '''
4508         ID of the secret store containing credentials for this resource, if any.
4509        '''
4510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4511        '''
4512         Tags is a map of key, value pairs.
4513        '''
4514        self.username = username if username is not None else ''
4515        '''
4516
4517        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4537    def to_dict(self):
4538        return {
4539            'auth_database': self.auth_database,
4540            'bind_interface': self.bind_interface,
4541            'connect_to_replica': self.connect_to_replica,
4542            'egress_filter': self.egress_filter,
4543            'healthy': self.healthy,
4544            'hostname': self.hostname,
4545            'id': self.id,
4546            'name': self.name,
4547            'password': self.password,
4548            'port_override': self.port_override,
4549            'replica_set': self.replica_set,
4550            'secret_store_id': self.secret_store_id,
4551            'tags': self.tags,
4552            'username': self.username,
4553        }
@classmethod
def from_dict(cls, d)
4555    @classmethod
4556    def from_dict(cls, d):
4557        return cls(
4558            auth_database=d.get('auth_database'),
4559            bind_interface=d.get('bind_interface'),
4560            connect_to_replica=d.get('connect_to_replica'),
4561            egress_filter=d.get('egress_filter'),
4562            healthy=d.get('healthy'),
4563            hostname=d.get('hostname'),
4564            id=d.get('id'),
4565            name=d.get('name'),
4566            password=d.get('password'),
4567            port_override=d.get('port_override'),
4568            replica_set=d.get('replica_set'),
4569            secret_store_id=d.get('secret_store_id'),
4570            tags=d.get('tags'),
4571            username=d.get('username'),
4572        )
class Druid:
4575class Druid:
4576    '''
4577
4578    '''
4579    __slots__ = [
4580        'bind_interface',
4581        'egress_filter',
4582        'healthy',
4583        'hostname',
4584        'id',
4585        'name',
4586        'password',
4587        'port',
4588        'port_override',
4589        'secret_store_id',
4590        'tags',
4591        'username',
4592    ]
4593
4594    def __init__(
4595        self,
4596        bind_interface=None,
4597        egress_filter=None,
4598        healthy=None,
4599        hostname=None,
4600        id=None,
4601        name=None,
4602        password=None,
4603        port=None,
4604        port_override=None,
4605        secret_store_id=None,
4606        tags=None,
4607        username=None,
4608    ):
4609        self.bind_interface = bind_interface if bind_interface is not None else ''
4610        '''
4611         Bind interface
4612        '''
4613        self.egress_filter = egress_filter if egress_filter is not None else ''
4614        '''
4615         A filter applied to the routing logic to pin datasource to nodes.
4616        '''
4617        self.healthy = healthy if healthy is not None else False
4618        '''
4619         True if the datasource is reachable and the credentials are valid.
4620        '''
4621        self.hostname = hostname if hostname is not None else ''
4622        '''
4623
4624        '''
4625        self.id = id if id is not None else ''
4626        '''
4627         Unique identifier of the Resource.
4628        '''
4629        self.name = name if name is not None else ''
4630        '''
4631         Unique human-readable name of the Resource.
4632        '''
4633        self.password = password if password is not None else ''
4634        '''
4635
4636        '''
4637        self.port = port if port is not None else 0
4638        '''
4639
4640        '''
4641        self.port_override = port_override if port_override is not None else 0
4642        '''
4643
4644        '''
4645        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4646        '''
4647         ID of the secret store containing credentials for this resource, if any.
4648        '''
4649        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4650        '''
4651         Tags is a map of key, value pairs.
4652        '''
4653        self.username = username if username is not None else ''
4654        '''
4655
4656        '''
4657
4658    def __repr__(self):
4659        return '<sdm.Druid ' + \
4660            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4661            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4662            'healthy: ' + repr(self.healthy) + ' ' +\
4663            'hostname: ' + repr(self.hostname) + ' ' +\
4664            'id: ' + repr(self.id) + ' ' +\
4665            'name: ' + repr(self.name) + ' ' +\
4666            'password: ' + repr(self.password) + ' ' +\
4667            'port: ' + repr(self.port) + ' ' +\
4668            'port_override: ' + repr(self.port_override) + ' ' +\
4669            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4670            'tags: ' + repr(self.tags) + ' ' +\
4671            'username: ' + repr(self.username) + ' ' +\
4672            '>'
4673
4674    def to_dict(self):
4675        return {
4676            'bind_interface': self.bind_interface,
4677            'egress_filter': self.egress_filter,
4678            'healthy': self.healthy,
4679            'hostname': self.hostname,
4680            'id': self.id,
4681            'name': self.name,
4682            'password': self.password,
4683            'port': self.port,
4684            'port_override': self.port_override,
4685            'secret_store_id': self.secret_store_id,
4686            'tags': self.tags,
4687            'username': self.username,
4688        }
4689
4690    @classmethod
4691    def from_dict(cls, d):
4692        return cls(
4693            bind_interface=d.get('bind_interface'),
4694            egress_filter=d.get('egress_filter'),
4695            healthy=d.get('healthy'),
4696            hostname=d.get('hostname'),
4697            id=d.get('id'),
4698            name=d.get('name'),
4699            password=d.get('password'),
4700            port=d.get('port'),
4701            port_override=d.get('port_override'),
4702            secret_store_id=d.get('secret_store_id'),
4703            tags=d.get('tags'),
4704            username=d.get('username'),
4705        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4594    def __init__(
4595        self,
4596        bind_interface=None,
4597        egress_filter=None,
4598        healthy=None,
4599        hostname=None,
4600        id=None,
4601        name=None,
4602        password=None,
4603        port=None,
4604        port_override=None,
4605        secret_store_id=None,
4606        tags=None,
4607        username=None,
4608    ):
4609        self.bind_interface = bind_interface if bind_interface is not None else ''
4610        '''
4611         Bind interface
4612        '''
4613        self.egress_filter = egress_filter if egress_filter is not None else ''
4614        '''
4615         A filter applied to the routing logic to pin datasource to nodes.
4616        '''
4617        self.healthy = healthy if healthy is not None else False
4618        '''
4619         True if the datasource is reachable and the credentials are valid.
4620        '''
4621        self.hostname = hostname if hostname is not None else ''
4622        '''
4623
4624        '''
4625        self.id = id if id is not None else ''
4626        '''
4627         Unique identifier of the Resource.
4628        '''
4629        self.name = name if name is not None else ''
4630        '''
4631         Unique human-readable name of the Resource.
4632        '''
4633        self.password = password if password is not None else ''
4634        '''
4635
4636        '''
4637        self.port = port if port is not None else 0
4638        '''
4639
4640        '''
4641        self.port_override = port_override if port_override is not None else 0
4642        '''
4643
4644        '''
4645        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4646        '''
4647         ID of the secret store containing credentials for this resource, if any.
4648        '''
4649        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4650        '''
4651         Tags is a map of key, value pairs.
4652        '''
4653        self.username = username if username is not None else ''
4654        '''
4655
4656        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4674    def to_dict(self):
4675        return {
4676            'bind_interface': self.bind_interface,
4677            'egress_filter': self.egress_filter,
4678            'healthy': self.healthy,
4679            'hostname': self.hostname,
4680            'id': self.id,
4681            'name': self.name,
4682            'password': self.password,
4683            'port': self.port,
4684            'port_override': self.port_override,
4685            'secret_store_id': self.secret_store_id,
4686            'tags': self.tags,
4687            'username': self.username,
4688        }
@classmethod
def from_dict(cls, d)
4690    @classmethod
4691    def from_dict(cls, d):
4692        return cls(
4693            bind_interface=d.get('bind_interface'),
4694            egress_filter=d.get('egress_filter'),
4695            healthy=d.get('healthy'),
4696            hostname=d.get('hostname'),
4697            id=d.get('id'),
4698            name=d.get('name'),
4699            password=d.get('password'),
4700            port=d.get('port'),
4701            port_override=d.get('port_override'),
4702            secret_store_id=d.get('secret_store_id'),
4703            tags=d.get('tags'),
4704            username=d.get('username'),
4705        )
class DynamoDB:
4708class DynamoDB:
4709    '''
4710
4711    '''
4712    __slots__ = [
4713        'access_key',
4714        'bind_interface',
4715        'egress_filter',
4716        'endpoint',
4717        'healthy',
4718        'id',
4719        'name',
4720        'port_override',
4721        'region',
4722        'role_arn',
4723        'role_external_id',
4724        'secret_access_key',
4725        'secret_store_id',
4726        'tags',
4727    ]
4728
4729    def __init__(
4730        self,
4731        access_key=None,
4732        bind_interface=None,
4733        egress_filter=None,
4734        endpoint=None,
4735        healthy=None,
4736        id=None,
4737        name=None,
4738        port_override=None,
4739        region=None,
4740        role_arn=None,
4741        role_external_id=None,
4742        secret_access_key=None,
4743        secret_store_id=None,
4744        tags=None,
4745    ):
4746        self.access_key = access_key if access_key is not None else ''
4747        '''
4748
4749        '''
4750        self.bind_interface = bind_interface if bind_interface is not None else ''
4751        '''
4752         Bind interface
4753        '''
4754        self.egress_filter = egress_filter if egress_filter is not None else ''
4755        '''
4756         A filter applied to the routing logic to pin datasource to nodes.
4757        '''
4758        self.endpoint = endpoint if endpoint is not None else ''
4759        '''
4760
4761        '''
4762        self.healthy = healthy if healthy is not None else False
4763        '''
4764         True if the datasource is reachable and the credentials are valid.
4765        '''
4766        self.id = id if id is not None else ''
4767        '''
4768         Unique identifier of the Resource.
4769        '''
4770        self.name = name if name is not None else ''
4771        '''
4772         Unique human-readable name of the Resource.
4773        '''
4774        self.port_override = port_override if port_override is not None else 0
4775        '''
4776
4777        '''
4778        self.region = region if region is not None else ''
4779        '''
4780
4781        '''
4782        self.role_arn = role_arn if role_arn is not None else ''
4783        '''
4784
4785        '''
4786        self.role_external_id = role_external_id if role_external_id is not None else ''
4787        '''
4788
4789        '''
4790        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4791        '''
4792
4793        '''
4794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4795        '''
4796         ID of the secret store containing credentials for this resource, if any.
4797        '''
4798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4799        '''
4800         Tags is a map of key, value pairs.
4801        '''
4802
4803    def __repr__(self):
4804        return '<sdm.DynamoDB ' + \
4805            'access_key: ' + repr(self.access_key) + ' ' +\
4806            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4807            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4808            'endpoint: ' + repr(self.endpoint) + ' ' +\
4809            'healthy: ' + repr(self.healthy) + ' ' +\
4810            'id: ' + repr(self.id) + ' ' +\
4811            'name: ' + repr(self.name) + ' ' +\
4812            'port_override: ' + repr(self.port_override) + ' ' +\
4813            'region: ' + repr(self.region) + ' ' +\
4814            'role_arn: ' + repr(self.role_arn) + ' ' +\
4815            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4816            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4818            'tags: ' + repr(self.tags) + ' ' +\
4819            '>'
4820
4821    def to_dict(self):
4822        return {
4823            'access_key': self.access_key,
4824            'bind_interface': self.bind_interface,
4825            'egress_filter': self.egress_filter,
4826            'endpoint': self.endpoint,
4827            'healthy': self.healthy,
4828            'id': self.id,
4829            'name': self.name,
4830            'port_override': self.port_override,
4831            'region': self.region,
4832            'role_arn': self.role_arn,
4833            'role_external_id': self.role_external_id,
4834            'secret_access_key': self.secret_access_key,
4835            'secret_store_id': self.secret_store_id,
4836            'tags': self.tags,
4837        }
4838
4839    @classmethod
4840    def from_dict(cls, d):
4841        return cls(
4842            access_key=d.get('access_key'),
4843            bind_interface=d.get('bind_interface'),
4844            egress_filter=d.get('egress_filter'),
4845            endpoint=d.get('endpoint'),
4846            healthy=d.get('healthy'),
4847            id=d.get('id'),
4848            name=d.get('name'),
4849            port_override=d.get('port_override'),
4850            region=d.get('region'),
4851            role_arn=d.get('role_arn'),
4852            role_external_id=d.get('role_external_id'),
4853            secret_access_key=d.get('secret_access_key'),
4854            secret_store_id=d.get('secret_store_id'),
4855            tags=d.get('tags'),
4856        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4729    def __init__(
4730        self,
4731        access_key=None,
4732        bind_interface=None,
4733        egress_filter=None,
4734        endpoint=None,
4735        healthy=None,
4736        id=None,
4737        name=None,
4738        port_override=None,
4739        region=None,
4740        role_arn=None,
4741        role_external_id=None,
4742        secret_access_key=None,
4743        secret_store_id=None,
4744        tags=None,
4745    ):
4746        self.access_key = access_key if access_key is not None else ''
4747        '''
4748
4749        '''
4750        self.bind_interface = bind_interface if bind_interface is not None else ''
4751        '''
4752         Bind interface
4753        '''
4754        self.egress_filter = egress_filter if egress_filter is not None else ''
4755        '''
4756         A filter applied to the routing logic to pin datasource to nodes.
4757        '''
4758        self.endpoint = endpoint if endpoint is not None else ''
4759        '''
4760
4761        '''
4762        self.healthy = healthy if healthy is not None else False
4763        '''
4764         True if the datasource is reachable and the credentials are valid.
4765        '''
4766        self.id = id if id is not None else ''
4767        '''
4768         Unique identifier of the Resource.
4769        '''
4770        self.name = name if name is not None else ''
4771        '''
4772         Unique human-readable name of the Resource.
4773        '''
4774        self.port_override = port_override if port_override is not None else 0
4775        '''
4776
4777        '''
4778        self.region = region if region is not None else ''
4779        '''
4780
4781        '''
4782        self.role_arn = role_arn if role_arn is not None else ''
4783        '''
4784
4785        '''
4786        self.role_external_id = role_external_id if role_external_id is not None else ''
4787        '''
4788
4789        '''
4790        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4791        '''
4792
4793        '''
4794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4795        '''
4796         ID of the secret store containing credentials for this resource, if any.
4797        '''
4798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4799        '''
4800         Tags is a map of key, value pairs.
4801        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4821    def to_dict(self):
4822        return {
4823            'access_key': self.access_key,
4824            'bind_interface': self.bind_interface,
4825            'egress_filter': self.egress_filter,
4826            'endpoint': self.endpoint,
4827            'healthy': self.healthy,
4828            'id': self.id,
4829            'name': self.name,
4830            'port_override': self.port_override,
4831            'region': self.region,
4832            'role_arn': self.role_arn,
4833            'role_external_id': self.role_external_id,
4834            'secret_access_key': self.secret_access_key,
4835            'secret_store_id': self.secret_store_id,
4836            'tags': self.tags,
4837        }
@classmethod
def from_dict(cls, d)
4839    @classmethod
4840    def from_dict(cls, d):
4841        return cls(
4842            access_key=d.get('access_key'),
4843            bind_interface=d.get('bind_interface'),
4844            egress_filter=d.get('egress_filter'),
4845            endpoint=d.get('endpoint'),
4846            healthy=d.get('healthy'),
4847            id=d.get('id'),
4848            name=d.get('name'),
4849            port_override=d.get('port_override'),
4850            region=d.get('region'),
4851            role_arn=d.get('role_arn'),
4852            role_external_id=d.get('role_external_id'),
4853            secret_access_key=d.get('secret_access_key'),
4854            secret_store_id=d.get('secret_store_id'),
4855            tags=d.get('tags'),
4856        )
class Elastic:
4859class Elastic:
4860    '''
4861
4862    '''
4863    __slots__ = [
4864        'bind_interface',
4865        'egress_filter',
4866        'healthy',
4867        'hostname',
4868        'id',
4869        'name',
4870        'password',
4871        'port',
4872        'port_override',
4873        'secret_store_id',
4874        'tags',
4875        'tls_required',
4876        'username',
4877    ]
4878
4879    def __init__(
4880        self,
4881        bind_interface=None,
4882        egress_filter=None,
4883        healthy=None,
4884        hostname=None,
4885        id=None,
4886        name=None,
4887        password=None,
4888        port=None,
4889        port_override=None,
4890        secret_store_id=None,
4891        tags=None,
4892        tls_required=None,
4893        username=None,
4894    ):
4895        self.bind_interface = bind_interface if bind_interface is not None else ''
4896        '''
4897         Bind interface
4898        '''
4899        self.egress_filter = egress_filter if egress_filter is not None else ''
4900        '''
4901         A filter applied to the routing logic to pin datasource to nodes.
4902        '''
4903        self.healthy = healthy if healthy is not None else False
4904        '''
4905         True if the datasource is reachable and the credentials are valid.
4906        '''
4907        self.hostname = hostname if hostname is not None else ''
4908        '''
4909
4910        '''
4911        self.id = id if id is not None else ''
4912        '''
4913         Unique identifier of the Resource.
4914        '''
4915        self.name = name if name is not None else ''
4916        '''
4917         Unique human-readable name of the Resource.
4918        '''
4919        self.password = password if password is not None else ''
4920        '''
4921
4922        '''
4923        self.port = port if port is not None else 0
4924        '''
4925
4926        '''
4927        self.port_override = port_override if port_override is not None else 0
4928        '''
4929
4930        '''
4931        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4932        '''
4933         ID of the secret store containing credentials for this resource, if any.
4934        '''
4935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4936        '''
4937         Tags is a map of key, value pairs.
4938        '''
4939        self.tls_required = tls_required if tls_required is not None else False
4940        '''
4941
4942        '''
4943        self.username = username if username is not None else ''
4944        '''
4945
4946        '''
4947
4948    def __repr__(self):
4949        return '<sdm.Elastic ' + \
4950            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4951            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4952            'healthy: ' + repr(self.healthy) + ' ' +\
4953            'hostname: ' + repr(self.hostname) + ' ' +\
4954            'id: ' + repr(self.id) + ' ' +\
4955            'name: ' + repr(self.name) + ' ' +\
4956            'password: ' + repr(self.password) + ' ' +\
4957            'port: ' + repr(self.port) + ' ' +\
4958            'port_override: ' + repr(self.port_override) + ' ' +\
4959            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4960            'tags: ' + repr(self.tags) + ' ' +\
4961            'tls_required: ' + repr(self.tls_required) + ' ' +\
4962            'username: ' + repr(self.username) + ' ' +\
4963            '>'
4964
4965    def to_dict(self):
4966        return {
4967            'bind_interface': self.bind_interface,
4968            'egress_filter': self.egress_filter,
4969            'healthy': self.healthy,
4970            'hostname': self.hostname,
4971            'id': self.id,
4972            'name': self.name,
4973            'password': self.password,
4974            'port': self.port,
4975            'port_override': self.port_override,
4976            'secret_store_id': self.secret_store_id,
4977            'tags': self.tags,
4978            'tls_required': self.tls_required,
4979            'username': self.username,
4980        }
4981
4982    @classmethod
4983    def from_dict(cls, d):
4984        return cls(
4985            bind_interface=d.get('bind_interface'),
4986            egress_filter=d.get('egress_filter'),
4987            healthy=d.get('healthy'),
4988            hostname=d.get('hostname'),
4989            id=d.get('id'),
4990            name=d.get('name'),
4991            password=d.get('password'),
4992            port=d.get('port'),
4993            port_override=d.get('port_override'),
4994            secret_store_id=d.get('secret_store_id'),
4995            tags=d.get('tags'),
4996            tls_required=d.get('tls_required'),
4997            username=d.get('username'),
4998        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4879    def __init__(
4880        self,
4881        bind_interface=None,
4882        egress_filter=None,
4883        healthy=None,
4884        hostname=None,
4885        id=None,
4886        name=None,
4887        password=None,
4888        port=None,
4889        port_override=None,
4890        secret_store_id=None,
4891        tags=None,
4892        tls_required=None,
4893        username=None,
4894    ):
4895        self.bind_interface = bind_interface if bind_interface is not None else ''
4896        '''
4897         Bind interface
4898        '''
4899        self.egress_filter = egress_filter if egress_filter is not None else ''
4900        '''
4901         A filter applied to the routing logic to pin datasource to nodes.
4902        '''
4903        self.healthy = healthy if healthy is not None else False
4904        '''
4905         True if the datasource is reachable and the credentials are valid.
4906        '''
4907        self.hostname = hostname if hostname is not None else ''
4908        '''
4909
4910        '''
4911        self.id = id if id is not None else ''
4912        '''
4913         Unique identifier of the Resource.
4914        '''
4915        self.name = name if name is not None else ''
4916        '''
4917         Unique human-readable name of the Resource.
4918        '''
4919        self.password = password if password is not None else ''
4920        '''
4921
4922        '''
4923        self.port = port if port is not None else 0
4924        '''
4925
4926        '''
4927        self.port_override = port_override if port_override is not None else 0
4928        '''
4929
4930        '''
4931        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4932        '''
4933         ID of the secret store containing credentials for this resource, if any.
4934        '''
4935        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4936        '''
4937         Tags is a map of key, value pairs.
4938        '''
4939        self.tls_required = tls_required if tls_required is not None else False
4940        '''
4941
4942        '''
4943        self.username = username if username is not None else ''
4944        '''
4945
4946        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4965    def to_dict(self):
4966        return {
4967            'bind_interface': self.bind_interface,
4968            'egress_filter': self.egress_filter,
4969            'healthy': self.healthy,
4970            'hostname': self.hostname,
4971            'id': self.id,
4972            'name': self.name,
4973            'password': self.password,
4974            'port': self.port,
4975            'port_override': self.port_override,
4976            'secret_store_id': self.secret_store_id,
4977            'tags': self.tags,
4978            'tls_required': self.tls_required,
4979            'username': self.username,
4980        }
@classmethod
def from_dict(cls, d)
4982    @classmethod
4983    def from_dict(cls, d):
4984        return cls(
4985            bind_interface=d.get('bind_interface'),
4986            egress_filter=d.get('egress_filter'),
4987            healthy=d.get('healthy'),
4988            hostname=d.get('hostname'),
4989            id=d.get('id'),
4990            name=d.get('name'),
4991            password=d.get('password'),
4992            port=d.get('port'),
4993            port_override=d.get('port_override'),
4994            secret_store_id=d.get('secret_store_id'),
4995            tags=d.get('tags'),
4996            tls_required=d.get('tls_required'),
4997            username=d.get('username'),
4998        )
class ElasticacheRedis:
5001class ElasticacheRedis:
5002    '''
5003
5004    '''
5005    __slots__ = [
5006        'bind_interface',
5007        'egress_filter',
5008        'healthy',
5009        'hostname',
5010        'id',
5011        'name',
5012        'password',
5013        'port',
5014        'port_override',
5015        'secret_store_id',
5016        'tags',
5017        'tls_required',
5018    ]
5019
5020    def __init__(
5021        self,
5022        bind_interface=None,
5023        egress_filter=None,
5024        healthy=None,
5025        hostname=None,
5026        id=None,
5027        name=None,
5028        password=None,
5029        port=None,
5030        port_override=None,
5031        secret_store_id=None,
5032        tags=None,
5033        tls_required=None,
5034    ):
5035        self.bind_interface = bind_interface if bind_interface is not None else ''
5036        '''
5037         Bind interface
5038        '''
5039        self.egress_filter = egress_filter if egress_filter is not None else ''
5040        '''
5041         A filter applied to the routing logic to pin datasource to nodes.
5042        '''
5043        self.healthy = healthy if healthy is not None else False
5044        '''
5045         True if the datasource is reachable and the credentials are valid.
5046        '''
5047        self.hostname = hostname if hostname is not None else ''
5048        '''
5049
5050        '''
5051        self.id = id if id is not None else ''
5052        '''
5053         Unique identifier of the Resource.
5054        '''
5055        self.name = name if name is not None else ''
5056        '''
5057         Unique human-readable name of the Resource.
5058        '''
5059        self.password = password if password is not None else ''
5060        '''
5061
5062        '''
5063        self.port = port if port is not None else 0
5064        '''
5065
5066        '''
5067        self.port_override = port_override if port_override is not None else 0
5068        '''
5069
5070        '''
5071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5072        '''
5073         ID of the secret store containing credentials for this resource, if any.
5074        '''
5075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5076        '''
5077         Tags is a map of key, value pairs.
5078        '''
5079        self.tls_required = tls_required if tls_required is not None else False
5080        '''
5081
5082        '''
5083
5084    def __repr__(self):
5085        return '<sdm.ElasticacheRedis ' + \
5086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5088            'healthy: ' + repr(self.healthy) + ' ' +\
5089            'hostname: ' + repr(self.hostname) + ' ' +\
5090            'id: ' + repr(self.id) + ' ' +\
5091            'name: ' + repr(self.name) + ' ' +\
5092            'password: ' + repr(self.password) + ' ' +\
5093            'port: ' + repr(self.port) + ' ' +\
5094            'port_override: ' + repr(self.port_override) + ' ' +\
5095            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5096            'tags: ' + repr(self.tags) + ' ' +\
5097            'tls_required: ' + repr(self.tls_required) + ' ' +\
5098            '>'
5099
5100    def to_dict(self):
5101        return {
5102            'bind_interface': self.bind_interface,
5103            'egress_filter': self.egress_filter,
5104            'healthy': self.healthy,
5105            'hostname': self.hostname,
5106            'id': self.id,
5107            'name': self.name,
5108            'password': self.password,
5109            'port': self.port,
5110            'port_override': self.port_override,
5111            'secret_store_id': self.secret_store_id,
5112            'tags': self.tags,
5113            'tls_required': self.tls_required,
5114        }
5115
5116    @classmethod
5117    def from_dict(cls, d):
5118        return cls(
5119            bind_interface=d.get('bind_interface'),
5120            egress_filter=d.get('egress_filter'),
5121            healthy=d.get('healthy'),
5122            hostname=d.get('hostname'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            password=d.get('password'),
5126            port=d.get('port'),
5127            port_override=d.get('port_override'),
5128            secret_store_id=d.get('secret_store_id'),
5129            tags=d.get('tags'),
5130            tls_required=d.get('tls_required'),
5131        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
5020    def __init__(
5021        self,
5022        bind_interface=None,
5023        egress_filter=None,
5024        healthy=None,
5025        hostname=None,
5026        id=None,
5027        name=None,
5028        password=None,
5029        port=None,
5030        port_override=None,
5031        secret_store_id=None,
5032        tags=None,
5033        tls_required=None,
5034    ):
5035        self.bind_interface = bind_interface if bind_interface is not None else ''
5036        '''
5037         Bind interface
5038        '''
5039        self.egress_filter = egress_filter if egress_filter is not None else ''
5040        '''
5041         A filter applied to the routing logic to pin datasource to nodes.
5042        '''
5043        self.healthy = healthy if healthy is not None else False
5044        '''
5045         True if the datasource is reachable and the credentials are valid.
5046        '''
5047        self.hostname = hostname if hostname is not None else ''
5048        '''
5049
5050        '''
5051        self.id = id if id is not None else ''
5052        '''
5053         Unique identifier of the Resource.
5054        '''
5055        self.name = name if name is not None else ''
5056        '''
5057         Unique human-readable name of the Resource.
5058        '''
5059        self.password = password if password is not None else ''
5060        '''
5061
5062        '''
5063        self.port = port if port is not None else 0
5064        '''
5065
5066        '''
5067        self.port_override = port_override if port_override is not None else 0
5068        '''
5069
5070        '''
5071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5072        '''
5073         ID of the secret store containing credentials for this resource, if any.
5074        '''
5075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5076        '''
5077         Tags is a map of key, value pairs.
5078        '''
5079        self.tls_required = tls_required if tls_required is not None else False
5080        '''
5081
5082        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
5100    def to_dict(self):
5101        return {
5102            'bind_interface': self.bind_interface,
5103            'egress_filter': self.egress_filter,
5104            'healthy': self.healthy,
5105            'hostname': self.hostname,
5106            'id': self.id,
5107            'name': self.name,
5108            'password': self.password,
5109            'port': self.port,
5110            'port_override': self.port_override,
5111            'secret_store_id': self.secret_store_id,
5112            'tags': self.tags,
5113            'tls_required': self.tls_required,
5114        }
@classmethod
def from_dict(cls, d)
5116    @classmethod
5117    def from_dict(cls, d):
5118        return cls(
5119            bind_interface=d.get('bind_interface'),
5120            egress_filter=d.get('egress_filter'),
5121            healthy=d.get('healthy'),
5122            hostname=d.get('hostname'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            password=d.get('password'),
5126            port=d.get('port'),
5127            port_override=d.get('port_override'),
5128            secret_store_id=d.get('secret_store_id'),
5129            tags=d.get('tags'),
5130            tls_required=d.get('tls_required'),
5131        )
class GCP:
5134class GCP:
5135    '''
5136
5137    '''
5138    __slots__ = [
5139        'bind_interface',
5140        'egress_filter',
5141        'healthy',
5142        'id',
5143        'keyfile',
5144        'name',
5145        'scopes',
5146        'secret_store_id',
5147        'tags',
5148    ]
5149
5150    def __init__(
5151        self,
5152        bind_interface=None,
5153        egress_filter=None,
5154        healthy=None,
5155        id=None,
5156        keyfile=None,
5157        name=None,
5158        scopes=None,
5159        secret_store_id=None,
5160        tags=None,
5161    ):
5162        self.bind_interface = bind_interface if bind_interface is not None else ''
5163        '''
5164         Bind interface
5165        '''
5166        self.egress_filter = egress_filter if egress_filter is not None else ''
5167        '''
5168         A filter applied to the routing logic to pin datasource to nodes.
5169        '''
5170        self.healthy = healthy if healthy is not None else False
5171        '''
5172         True if the datasource is reachable and the credentials are valid.
5173        '''
5174        self.id = id if id is not None else ''
5175        '''
5176         Unique identifier of the Resource.
5177        '''
5178        self.keyfile = keyfile if keyfile is not None else ''
5179        '''
5180
5181        '''
5182        self.name = name if name is not None else ''
5183        '''
5184         Unique human-readable name of the Resource.
5185        '''
5186        self.scopes = scopes if scopes is not None else ''
5187        '''
5188
5189        '''
5190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5191        '''
5192         ID of the secret store containing credentials for this resource, if any.
5193        '''
5194        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5195        '''
5196         Tags is a map of key, value pairs.
5197        '''
5198
5199    def __repr__(self):
5200        return '<sdm.GCP ' + \
5201            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5202            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5203            'healthy: ' + repr(self.healthy) + ' ' +\
5204            'id: ' + repr(self.id) + ' ' +\
5205            'keyfile: ' + repr(self.keyfile) + ' ' +\
5206            'name: ' + repr(self.name) + ' ' +\
5207            'scopes: ' + repr(self.scopes) + ' ' +\
5208            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5209            'tags: ' + repr(self.tags) + ' ' +\
5210            '>'
5211
5212    def to_dict(self):
5213        return {
5214            'bind_interface': self.bind_interface,
5215            'egress_filter': self.egress_filter,
5216            'healthy': self.healthy,
5217            'id': self.id,
5218            'keyfile': self.keyfile,
5219            'name': self.name,
5220            'scopes': self.scopes,
5221            'secret_store_id': self.secret_store_id,
5222            'tags': self.tags,
5223        }
5224
5225    @classmethod
5226    def from_dict(cls, d):
5227        return cls(
5228            bind_interface=d.get('bind_interface'),
5229            egress_filter=d.get('egress_filter'),
5230            healthy=d.get('healthy'),
5231            id=d.get('id'),
5232            keyfile=d.get('keyfile'),
5233            name=d.get('name'),
5234            scopes=d.get('scopes'),
5235            secret_store_id=d.get('secret_store_id'),
5236            tags=d.get('tags'),
5237        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5150    def __init__(
5151        self,
5152        bind_interface=None,
5153        egress_filter=None,
5154        healthy=None,
5155        id=None,
5156        keyfile=None,
5157        name=None,
5158        scopes=None,
5159        secret_store_id=None,
5160        tags=None,
5161    ):
5162        self.bind_interface = bind_interface if bind_interface is not None else ''
5163        '''
5164         Bind interface
5165        '''
5166        self.egress_filter = egress_filter if egress_filter is not None else ''
5167        '''
5168         A filter applied to the routing logic to pin datasource to nodes.
5169        '''
5170        self.healthy = healthy if healthy is not None else False
5171        '''
5172         True if the datasource is reachable and the credentials are valid.
5173        '''
5174        self.id = id if id is not None else ''
5175        '''
5176         Unique identifier of the Resource.
5177        '''
5178        self.keyfile = keyfile if keyfile is not None else ''
5179        '''
5180
5181        '''
5182        self.name = name if name is not None else ''
5183        '''
5184         Unique human-readable name of the Resource.
5185        '''
5186        self.scopes = scopes if scopes is not None else ''
5187        '''
5188
5189        '''
5190        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5191        '''
5192         ID of the secret store containing credentials for this resource, if any.
5193        '''
5194        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5195        '''
5196         Tags is a map of key, value pairs.
5197        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5212    def to_dict(self):
5213        return {
5214            'bind_interface': self.bind_interface,
5215            'egress_filter': self.egress_filter,
5216            'healthy': self.healthy,
5217            'id': self.id,
5218            'keyfile': self.keyfile,
5219            'name': self.name,
5220            'scopes': self.scopes,
5221            'secret_store_id': self.secret_store_id,
5222            'tags': self.tags,
5223        }
@classmethod
def from_dict(cls, d)
5225    @classmethod
5226    def from_dict(cls, d):
5227        return cls(
5228            bind_interface=d.get('bind_interface'),
5229            egress_filter=d.get('egress_filter'),
5230            healthy=d.get('healthy'),
5231            id=d.get('id'),
5232            keyfile=d.get('keyfile'),
5233            name=d.get('name'),
5234            scopes=d.get('scopes'),
5235            secret_store_id=d.get('secret_store_id'),
5236            tags=d.get('tags'),
5237        )
class GCPStore:
5240class GCPStore:
5241    '''
5242
5243    '''
5244    __slots__ = [
5245        'id',
5246        'name',
5247        'projectid',
5248        'tags',
5249    ]
5250
5251    def __init__(
5252        self,
5253        id=None,
5254        name=None,
5255        projectid=None,
5256        tags=None,
5257    ):
5258        self.id = id if id is not None else ''
5259        '''
5260         Unique identifier of the SecretStore.
5261        '''
5262        self.name = name if name is not None else ''
5263        '''
5264         Unique human-readable name of the SecretStore.
5265        '''
5266        self.projectid = projectid if projectid is not None else ''
5267        '''
5268
5269        '''
5270        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5271        '''
5272         Tags is a map of key, value pairs.
5273        '''
5274
5275    def __repr__(self):
5276        return '<sdm.GCPStore ' + \
5277            'id: ' + repr(self.id) + ' ' +\
5278            'name: ' + repr(self.name) + ' ' +\
5279            'projectid: ' + repr(self.projectid) + ' ' +\
5280            'tags: ' + repr(self.tags) + ' ' +\
5281            '>'
5282
5283    def to_dict(self):
5284        return {
5285            'id': self.id,
5286            'name': self.name,
5287            'projectid': self.projectid,
5288            'tags': self.tags,
5289        }
5290
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            id=d.get('id'),
5295            name=d.get('name'),
5296            projectid=d.get('projectid'),
5297            tags=d.get('tags'),
5298        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5251    def __init__(
5252        self,
5253        id=None,
5254        name=None,
5255        projectid=None,
5256        tags=None,
5257    ):
5258        self.id = id if id is not None else ''
5259        '''
5260         Unique identifier of the SecretStore.
5261        '''
5262        self.name = name if name is not None else ''
5263        '''
5264         Unique human-readable name of the SecretStore.
5265        '''
5266        self.projectid = projectid if projectid is not None else ''
5267        '''
5268
5269        '''
5270        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5271        '''
5272         Tags is a map of key, value pairs.
5273        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5283    def to_dict(self):
5284        return {
5285            'id': self.id,
5286            'name': self.name,
5287            'projectid': self.projectid,
5288            'tags': self.tags,
5289        }
@classmethod
def from_dict(cls, d)
5291    @classmethod
5292    def from_dict(cls, d):
5293        return cls(
5294            id=d.get('id'),
5295            name=d.get('name'),
5296            projectid=d.get('projectid'),
5297            tags=d.get('tags'),
5298        )
class Gateway:
5301class Gateway:
5302    '''
5303     Gateway represents a StrongDM CLI installation running in gateway mode.
5304    '''
5305    __slots__ = [
5306        'bind_address',
5307        'gateway_filter',
5308        'id',
5309        'listen_address',
5310        'name',
5311        'state',
5312        'tags',
5313    ]
5314
5315    def __init__(
5316        self,
5317        bind_address=None,
5318        gateway_filter=None,
5319        id=None,
5320        listen_address=None,
5321        name=None,
5322        state=None,
5323        tags=None,
5324    ):
5325        self.bind_address = bind_address if bind_address is not None else ''
5326        '''
5327         The hostname/port tuple which the gateway daemon will bind to.
5328         If not provided on create, set to "0.0.0.0:listen_address_port".
5329        '''
5330        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5331        '''
5332         GatewayFilter can be used to restrict the peering between relays and
5333         gateways.
5334        '''
5335        self.id = id if id is not None else ''
5336        '''
5337         Unique identifier of the Gateway.
5338        '''
5339        self.listen_address = listen_address if listen_address is not None else ''
5340        '''
5341         The public hostname/port tuple at which the gateway will be accessible to clients.
5342        '''
5343        self.name = name if name is not None else ''
5344        '''
5345         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5346        '''
5347        self.state = state if state is not None else ''
5348        '''
5349         The current state of the gateway. One of: "new", "verifying_restart",
5350         "restarting", "started", "stopped", "dead", "unknown"
5351        '''
5352        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5353        '''
5354         Tags is a map of key, value pairs.
5355        '''
5356
5357    def __repr__(self):
5358        return '<sdm.Gateway ' + \
5359            'bind_address: ' + repr(self.bind_address) + ' ' +\
5360            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5361            'id: ' + repr(self.id) + ' ' +\
5362            'listen_address: ' + repr(self.listen_address) + ' ' +\
5363            'name: ' + repr(self.name) + ' ' +\
5364            'state: ' + repr(self.state) + ' ' +\
5365            'tags: ' + repr(self.tags) + ' ' +\
5366            '>'
5367
5368    def to_dict(self):
5369        return {
5370            'bind_address': self.bind_address,
5371            'gateway_filter': self.gateway_filter,
5372            'id': self.id,
5373            'listen_address': self.listen_address,
5374            'name': self.name,
5375            'state': self.state,
5376            'tags': self.tags,
5377        }
5378
5379    @classmethod
5380    def from_dict(cls, d):
5381        return cls(
5382            bind_address=d.get('bind_address'),
5383            gateway_filter=d.get('gateway_filter'),
5384            id=d.get('id'),
5385            listen_address=d.get('listen_address'),
5386            name=d.get('name'),
5387            state=d.get('state'),
5388            tags=d.get('tags'),
5389        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
5315    def __init__(
5316        self,
5317        bind_address=None,
5318        gateway_filter=None,
5319        id=None,
5320        listen_address=None,
5321        name=None,
5322        state=None,
5323        tags=None,
5324    ):
5325        self.bind_address = bind_address if bind_address is not None else ''
5326        '''
5327         The hostname/port tuple which the gateway daemon will bind to.
5328         If not provided on create, set to "0.0.0.0:listen_address_port".
5329        '''
5330        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5331        '''
5332         GatewayFilter can be used to restrict the peering between relays and
5333         gateways.
5334        '''
5335        self.id = id if id is not None else ''
5336        '''
5337         Unique identifier of the Gateway.
5338        '''
5339        self.listen_address = listen_address if listen_address is not None else ''
5340        '''
5341         The public hostname/port tuple at which the gateway will be accessible to clients.
5342        '''
5343        self.name = name if name is not None else ''
5344        '''
5345         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5346        '''
5347        self.state = state if state is not None else ''
5348        '''
5349         The current state of the gateway. One of: "new", "verifying_restart",
5350         "restarting", "started", "stopped", "dead", "unknown"
5351        '''
5352        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5353        '''
5354         Tags is a map of key, value pairs.
5355        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
5368    def to_dict(self):
5369        return {
5370            'bind_address': self.bind_address,
5371            'gateway_filter': self.gateway_filter,
5372            'id': self.id,
5373            'listen_address': self.listen_address,
5374            'name': self.name,
5375            'state': self.state,
5376            'tags': self.tags,
5377        }
@classmethod
def from_dict(cls, d)
5379    @classmethod
5380    def from_dict(cls, d):
5381        return cls(
5382            bind_address=d.get('bind_address'),
5383            gateway_filter=d.get('gateway_filter'),
5384            id=d.get('id'),
5385            listen_address=d.get('listen_address'),
5386            name=d.get('name'),
5387            state=d.get('state'),
5388            tags=d.get('tags'),
5389        )
class GetResponseMetadata:
5392class GetResponseMetadata:
5393    '''
5394     GetResponseMetadata is reserved for future use.
5395    '''
5396    __slots__ = []
5397
5398    def __init__(self, ):
5399        pass
5400
5401    def __repr__(self):
5402        return '<sdm.GetResponseMetadata ' + \
5403            '>'
5404
5405    def to_dict(self):
5406        return {}
5407
5408    @classmethod
5409    def from_dict(cls, d):
5410        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5398    def __init__(self, ):
5399        pass
def to_dict(self)
5405    def to_dict(self):
5406        return {}
@classmethod
def from_dict(cls, d)
5408    @classmethod
5409    def from_dict(cls, d):
5410        return cls()
class GoogleGKE:
5413class GoogleGKE:
5414    '''
5415
5416    '''
5417    __slots__ = [
5418        'bind_interface',
5419        'certificate_authority',
5420        'egress_filter',
5421        'endpoint',
5422        'healthcheck_namespace',
5423        'healthy',
5424        'id',
5425        'name',
5426        'remote_identity_group_id',
5427        'remote_identity_healthcheck_username',
5428        'secret_store_id',
5429        'service_account_key',
5430        'tags',
5431    ]
5432
5433    def __init__(
5434        self,
5435        bind_interface=None,
5436        certificate_authority=None,
5437        egress_filter=None,
5438        endpoint=None,
5439        healthcheck_namespace=None,
5440        healthy=None,
5441        id=None,
5442        name=None,
5443        remote_identity_group_id=None,
5444        remote_identity_healthcheck_username=None,
5445        secret_store_id=None,
5446        service_account_key=None,
5447        tags=None,
5448    ):
5449        self.bind_interface = bind_interface if bind_interface is not None else ''
5450        '''
5451         Bind interface
5452        '''
5453        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5454        '''
5455
5456        '''
5457        self.egress_filter = egress_filter if egress_filter is not None else ''
5458        '''
5459         A filter applied to the routing logic to pin datasource to nodes.
5460        '''
5461        self.endpoint = endpoint if endpoint is not None else ''
5462        '''
5463
5464        '''
5465        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5466        '''
5467         The path used to check the health of your connection.  Defaults to `default`.
5468        '''
5469        self.healthy = healthy if healthy is not None else False
5470        '''
5471         True if the datasource is reachable and the credentials are valid.
5472        '''
5473        self.id = id if id is not None else ''
5474        '''
5475         Unique identifier of the Resource.
5476        '''
5477        self.name = name if name is not None else ''
5478        '''
5479         Unique human-readable name of the Resource.
5480        '''
5481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5482        '''
5483
5484        '''
5485        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5486        '''
5487
5488        '''
5489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5490        '''
5491         ID of the secret store containing credentials for this resource, if any.
5492        '''
5493        self.service_account_key = service_account_key if service_account_key is not None else ''
5494        '''
5495
5496        '''
5497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5498        '''
5499         Tags is a map of key, value pairs.
5500        '''
5501
5502    def __repr__(self):
5503        return '<sdm.GoogleGKE ' + \
5504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5505            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5507            'endpoint: ' + repr(self.endpoint) + ' ' +\
5508            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5509            'healthy: ' + repr(self.healthy) + ' ' +\
5510            'id: ' + repr(self.id) + ' ' +\
5511            'name: ' + repr(self.name) + ' ' +\
5512            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5513            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5515            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5516            'tags: ' + repr(self.tags) + ' ' +\
5517            '>'
5518
5519    def to_dict(self):
5520        return {
5521            'bind_interface': self.bind_interface,
5522            'certificate_authority': self.certificate_authority,
5523            'egress_filter': self.egress_filter,
5524            'endpoint': self.endpoint,
5525            'healthcheck_namespace': self.healthcheck_namespace,
5526            'healthy': self.healthy,
5527            'id': self.id,
5528            'name': self.name,
5529            'remote_identity_group_id': self.remote_identity_group_id,
5530            'remote_identity_healthcheck_username':
5531            self.remote_identity_healthcheck_username,
5532            'secret_store_id': self.secret_store_id,
5533            'service_account_key': self.service_account_key,
5534            'tags': self.tags,
5535        }
5536
5537    @classmethod
5538    def from_dict(cls, d):
5539        return cls(
5540            bind_interface=d.get('bind_interface'),
5541            certificate_authority=d.get('certificate_authority'),
5542            egress_filter=d.get('egress_filter'),
5543            endpoint=d.get('endpoint'),
5544            healthcheck_namespace=d.get('healthcheck_namespace'),
5545            healthy=d.get('healthy'),
5546            id=d.get('id'),
5547            name=d.get('name'),
5548            remote_identity_group_id=d.get('remote_identity_group_id'),
5549            remote_identity_healthcheck_username=d.get(
5550                'remote_identity_healthcheck_username'),
5551            secret_store_id=d.get('secret_store_id'),
5552            service_account_key=d.get('service_account_key'),
5553            tags=d.get('tags'),
5554        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5433    def __init__(
5434        self,
5435        bind_interface=None,
5436        certificate_authority=None,
5437        egress_filter=None,
5438        endpoint=None,
5439        healthcheck_namespace=None,
5440        healthy=None,
5441        id=None,
5442        name=None,
5443        remote_identity_group_id=None,
5444        remote_identity_healthcheck_username=None,
5445        secret_store_id=None,
5446        service_account_key=None,
5447        tags=None,
5448    ):
5449        self.bind_interface = bind_interface if bind_interface is not None else ''
5450        '''
5451         Bind interface
5452        '''
5453        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5454        '''
5455
5456        '''
5457        self.egress_filter = egress_filter if egress_filter is not None else ''
5458        '''
5459         A filter applied to the routing logic to pin datasource to nodes.
5460        '''
5461        self.endpoint = endpoint if endpoint is not None else ''
5462        '''
5463
5464        '''
5465        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5466        '''
5467         The path used to check the health of your connection.  Defaults to `default`.
5468        '''
5469        self.healthy = healthy if healthy is not None else False
5470        '''
5471         True if the datasource is reachable and the credentials are valid.
5472        '''
5473        self.id = id if id is not None else ''
5474        '''
5475         Unique identifier of the Resource.
5476        '''
5477        self.name = name if name is not None else ''
5478        '''
5479         Unique human-readable name of the Resource.
5480        '''
5481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5482        '''
5483
5484        '''
5485        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5486        '''
5487
5488        '''
5489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5490        '''
5491         ID of the secret store containing credentials for this resource, if any.
5492        '''
5493        self.service_account_key = service_account_key if service_account_key is not None else ''
5494        '''
5495
5496        '''
5497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5498        '''
5499         Tags is a map of key, value pairs.
5500        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5519    def to_dict(self):
5520        return {
5521            'bind_interface': self.bind_interface,
5522            'certificate_authority': self.certificate_authority,
5523            'egress_filter': self.egress_filter,
5524            'endpoint': self.endpoint,
5525            'healthcheck_namespace': self.healthcheck_namespace,
5526            'healthy': self.healthy,
5527            'id': self.id,
5528            'name': self.name,
5529            'remote_identity_group_id': self.remote_identity_group_id,
5530            'remote_identity_healthcheck_username':
5531            self.remote_identity_healthcheck_username,
5532            'secret_store_id': self.secret_store_id,
5533            'service_account_key': self.service_account_key,
5534            'tags': self.tags,
5535        }
@classmethod
def from_dict(cls, d)
5537    @classmethod
5538    def from_dict(cls, d):
5539        return cls(
5540            bind_interface=d.get('bind_interface'),
5541            certificate_authority=d.get('certificate_authority'),
5542            egress_filter=d.get('egress_filter'),
5543            endpoint=d.get('endpoint'),
5544            healthcheck_namespace=d.get('healthcheck_namespace'),
5545            healthy=d.get('healthy'),
5546            id=d.get('id'),
5547            name=d.get('name'),
5548            remote_identity_group_id=d.get('remote_identity_group_id'),
5549            remote_identity_healthcheck_username=d.get(
5550                'remote_identity_healthcheck_username'),
5551            secret_store_id=d.get('secret_store_id'),
5552            service_account_key=d.get('service_account_key'),
5553            tags=d.get('tags'),
5554        )
class GoogleGKEUserImpersonation:
5557class GoogleGKEUserImpersonation:
5558    '''
5559
5560    '''
5561    __slots__ = [
5562        'bind_interface',
5563        'certificate_authority',
5564        'egress_filter',
5565        'endpoint',
5566        'healthcheck_namespace',
5567        'healthy',
5568        'id',
5569        'name',
5570        'secret_store_id',
5571        'service_account_key',
5572        'tags',
5573    ]
5574
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        certificate_authority=None,
5579        egress_filter=None,
5580        endpoint=None,
5581        healthcheck_namespace=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        service_account_key=None,
5587        tags=None,
5588    ):
5589        self.bind_interface = bind_interface if bind_interface is not None else ''
5590        '''
5591         Bind interface
5592        '''
5593        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5594        '''
5595
5596        '''
5597        self.egress_filter = egress_filter if egress_filter is not None else ''
5598        '''
5599         A filter applied to the routing logic to pin datasource to nodes.
5600        '''
5601        self.endpoint = endpoint if endpoint is not None else ''
5602        '''
5603
5604        '''
5605        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5606        '''
5607         The path used to check the health of your connection.  Defaults to `default`.
5608        '''
5609        self.healthy = healthy if healthy is not None else False
5610        '''
5611         True if the datasource is reachable and the credentials are valid.
5612        '''
5613        self.id = id if id is not None else ''
5614        '''
5615         Unique identifier of the Resource.
5616        '''
5617        self.name = name if name is not None else ''
5618        '''
5619         Unique human-readable name of the Resource.
5620        '''
5621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5622        '''
5623         ID of the secret store containing credentials for this resource, if any.
5624        '''
5625        self.service_account_key = service_account_key if service_account_key is not None else ''
5626        '''
5627
5628        '''
5629        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5630        '''
5631         Tags is a map of key, value pairs.
5632        '''
5633
5634    def __repr__(self):
5635        return '<sdm.GoogleGKEUserImpersonation ' + \
5636            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5637            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5638            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5639            'endpoint: ' + repr(self.endpoint) + ' ' +\
5640            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5641            'healthy: ' + repr(self.healthy) + ' ' +\
5642            'id: ' + repr(self.id) + ' ' +\
5643            'name: ' + repr(self.name) + ' ' +\
5644            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5645            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5646            'tags: ' + repr(self.tags) + ' ' +\
5647            '>'
5648
5649    def to_dict(self):
5650        return {
5651            'bind_interface': self.bind_interface,
5652            'certificate_authority': self.certificate_authority,
5653            'egress_filter': self.egress_filter,
5654            'endpoint': self.endpoint,
5655            'healthcheck_namespace': self.healthcheck_namespace,
5656            'healthy': self.healthy,
5657            'id': self.id,
5658            'name': self.name,
5659            'secret_store_id': self.secret_store_id,
5660            'service_account_key': self.service_account_key,
5661            'tags': self.tags,
5662        }
5663
5664    @classmethod
5665    def from_dict(cls, d):
5666        return cls(
5667            bind_interface=d.get('bind_interface'),
5668            certificate_authority=d.get('certificate_authority'),
5669            egress_filter=d.get('egress_filter'),
5670            endpoint=d.get('endpoint'),
5671            healthcheck_namespace=d.get('healthcheck_namespace'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            secret_store_id=d.get('secret_store_id'),
5676            service_account_key=d.get('service_account_key'),
5677            tags=d.get('tags'),
5678        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5575    def __init__(
5576        self,
5577        bind_interface=None,
5578        certificate_authority=None,
5579        egress_filter=None,
5580        endpoint=None,
5581        healthcheck_namespace=None,
5582        healthy=None,
5583        id=None,
5584        name=None,
5585        secret_store_id=None,
5586        service_account_key=None,
5587        tags=None,
5588    ):
5589        self.bind_interface = bind_interface if bind_interface is not None else ''
5590        '''
5591         Bind interface
5592        '''
5593        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5594        '''
5595
5596        '''
5597        self.egress_filter = egress_filter if egress_filter is not None else ''
5598        '''
5599         A filter applied to the routing logic to pin datasource to nodes.
5600        '''
5601        self.endpoint = endpoint if endpoint is not None else ''
5602        '''
5603
5604        '''
5605        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5606        '''
5607         The path used to check the health of your connection.  Defaults to `default`.
5608        '''
5609        self.healthy = healthy if healthy is not None else False
5610        '''
5611         True if the datasource is reachable and the credentials are valid.
5612        '''
5613        self.id = id if id is not None else ''
5614        '''
5615         Unique identifier of the Resource.
5616        '''
5617        self.name = name if name is not None else ''
5618        '''
5619         Unique human-readable name of the Resource.
5620        '''
5621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5622        '''
5623         ID of the secret store containing credentials for this resource, if any.
5624        '''
5625        self.service_account_key = service_account_key if service_account_key is not None else ''
5626        '''
5627
5628        '''
5629        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5630        '''
5631         Tags is a map of key, value pairs.
5632        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5649    def to_dict(self):
5650        return {
5651            'bind_interface': self.bind_interface,
5652            'certificate_authority': self.certificate_authority,
5653            'egress_filter': self.egress_filter,
5654            'endpoint': self.endpoint,
5655            'healthcheck_namespace': self.healthcheck_namespace,
5656            'healthy': self.healthy,
5657            'id': self.id,
5658            'name': self.name,
5659            'secret_store_id': self.secret_store_id,
5660            'service_account_key': self.service_account_key,
5661            'tags': self.tags,
5662        }
@classmethod
def from_dict(cls, d)
5664    @classmethod
5665    def from_dict(cls, d):
5666        return cls(
5667            bind_interface=d.get('bind_interface'),
5668            certificate_authority=d.get('certificate_authority'),
5669            egress_filter=d.get('egress_filter'),
5670            endpoint=d.get('endpoint'),
5671            healthcheck_namespace=d.get('healthcheck_namespace'),
5672            healthy=d.get('healthy'),
5673            id=d.get('id'),
5674            name=d.get('name'),
5675            secret_store_id=d.get('secret_store_id'),
5676            service_account_key=d.get('service_account_key'),
5677            tags=d.get('tags'),
5678        )
class Greenplum:
5681class Greenplum:
5682    '''
5683
5684    '''
5685    __slots__ = [
5686        'bind_interface',
5687        'database',
5688        'egress_filter',
5689        'healthy',
5690        'hostname',
5691        'id',
5692        'name',
5693        'override_database',
5694        'password',
5695        'port',
5696        'port_override',
5697        'secret_store_id',
5698        'tags',
5699        'username',
5700    ]
5701
5702    def __init__(
5703        self,
5704        bind_interface=None,
5705        database=None,
5706        egress_filter=None,
5707        healthy=None,
5708        hostname=None,
5709        id=None,
5710        name=None,
5711        override_database=None,
5712        password=None,
5713        port=None,
5714        port_override=None,
5715        secret_store_id=None,
5716        tags=None,
5717        username=None,
5718    ):
5719        self.bind_interface = bind_interface if bind_interface is not None else ''
5720        '''
5721         Bind interface
5722        '''
5723        self.database = database if database is not None else ''
5724        '''
5725
5726        '''
5727        self.egress_filter = egress_filter if egress_filter is not None else ''
5728        '''
5729         A filter applied to the routing logic to pin datasource to nodes.
5730        '''
5731        self.healthy = healthy if healthy is not None else False
5732        '''
5733         True if the datasource is reachable and the credentials are valid.
5734        '''
5735        self.hostname = hostname if hostname is not None else ''
5736        '''
5737
5738        '''
5739        self.id = id if id is not None else ''
5740        '''
5741         Unique identifier of the Resource.
5742        '''
5743        self.name = name if name is not None else ''
5744        '''
5745         Unique human-readable name of the Resource.
5746        '''
5747        self.override_database = override_database if override_database is not None else False
5748        '''
5749
5750        '''
5751        self.password = password if password is not None else ''
5752        '''
5753
5754        '''
5755        self.port = port if port is not None else 0
5756        '''
5757
5758        '''
5759        self.port_override = port_override if port_override is not None else 0
5760        '''
5761
5762        '''
5763        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5764        '''
5765         ID of the secret store containing credentials for this resource, if any.
5766        '''
5767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5768        '''
5769         Tags is a map of key, value pairs.
5770        '''
5771        self.username = username if username is not None else ''
5772        '''
5773
5774        '''
5775
5776    def __repr__(self):
5777        return '<sdm.Greenplum ' + \
5778            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5779            'database: ' + repr(self.database) + ' ' +\
5780            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5781            'healthy: ' + repr(self.healthy) + ' ' +\
5782            'hostname: ' + repr(self.hostname) + ' ' +\
5783            'id: ' + repr(self.id) + ' ' +\
5784            'name: ' + repr(self.name) + ' ' +\
5785            'override_database: ' + repr(self.override_database) + ' ' +\
5786            'password: ' + repr(self.password) + ' ' +\
5787            'port: ' + repr(self.port) + ' ' +\
5788            'port_override: ' + repr(self.port_override) + ' ' +\
5789            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5790            'tags: ' + repr(self.tags) + ' ' +\
5791            'username: ' + repr(self.username) + ' ' +\
5792            '>'
5793
5794    def to_dict(self):
5795        return {
5796            'bind_interface': self.bind_interface,
5797            'database': self.database,
5798            'egress_filter': self.egress_filter,
5799            'healthy': self.healthy,
5800            'hostname': self.hostname,
5801            'id': self.id,
5802            'name': self.name,
5803            'override_database': self.override_database,
5804            'password': self.password,
5805            'port': self.port,
5806            'port_override': self.port_override,
5807            'secret_store_id': self.secret_store_id,
5808            'tags': self.tags,
5809            'username': self.username,
5810        }
5811
5812    @classmethod
5813    def from_dict(cls, d):
5814        return cls(
5815            bind_interface=d.get('bind_interface'),
5816            database=d.get('database'),
5817            egress_filter=d.get('egress_filter'),
5818            healthy=d.get('healthy'),
5819            hostname=d.get('hostname'),
5820            id=d.get('id'),
5821            name=d.get('name'),
5822            override_database=d.get('override_database'),
5823            password=d.get('password'),
5824            port=d.get('port'),
5825            port_override=d.get('port_override'),
5826            secret_store_id=d.get('secret_store_id'),
5827            tags=d.get('tags'),
5828            username=d.get('username'),
5829        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5702    def __init__(
5703        self,
5704        bind_interface=None,
5705        database=None,
5706        egress_filter=None,
5707        healthy=None,
5708        hostname=None,
5709        id=None,
5710        name=None,
5711        override_database=None,
5712        password=None,
5713        port=None,
5714        port_override=None,
5715        secret_store_id=None,
5716        tags=None,
5717        username=None,
5718    ):
5719        self.bind_interface = bind_interface if bind_interface is not None else ''
5720        '''
5721         Bind interface
5722        '''
5723        self.database = database if database is not None else ''
5724        '''
5725
5726        '''
5727        self.egress_filter = egress_filter if egress_filter is not None else ''
5728        '''
5729         A filter applied to the routing logic to pin datasource to nodes.
5730        '''
5731        self.healthy = healthy if healthy is not None else False
5732        '''
5733         True if the datasource is reachable and the credentials are valid.
5734        '''
5735        self.hostname = hostname if hostname is not None else ''
5736        '''
5737
5738        '''
5739        self.id = id if id is not None else ''
5740        '''
5741         Unique identifier of the Resource.
5742        '''
5743        self.name = name if name is not None else ''
5744        '''
5745         Unique human-readable name of the Resource.
5746        '''
5747        self.override_database = override_database if override_database is not None else False
5748        '''
5749
5750        '''
5751        self.password = password if password is not None else ''
5752        '''
5753
5754        '''
5755        self.port = port if port is not None else 0
5756        '''
5757
5758        '''
5759        self.port_override = port_override if port_override is not None else 0
5760        '''
5761
5762        '''
5763        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5764        '''
5765         ID of the secret store containing credentials for this resource, if any.
5766        '''
5767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5768        '''
5769         Tags is a map of key, value pairs.
5770        '''
5771        self.username = username if username is not None else ''
5772        '''
5773
5774        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5794    def to_dict(self):
5795        return {
5796            'bind_interface': self.bind_interface,
5797            'database': self.database,
5798            'egress_filter': self.egress_filter,
5799            'healthy': self.healthy,
5800            'hostname': self.hostname,
5801            'id': self.id,
5802            'name': self.name,
5803            'override_database': self.override_database,
5804            'password': self.password,
5805            'port': self.port,
5806            'port_override': self.port_override,
5807            'secret_store_id': self.secret_store_id,
5808            'tags': self.tags,
5809            'username': self.username,
5810        }
@classmethod
def from_dict(cls, d)
5812    @classmethod
5813    def from_dict(cls, d):
5814        return cls(
5815            bind_interface=d.get('bind_interface'),
5816            database=d.get('database'),
5817            egress_filter=d.get('egress_filter'),
5818            healthy=d.get('healthy'),
5819            hostname=d.get('hostname'),
5820            id=d.get('id'),
5821            name=d.get('name'),
5822            override_database=d.get('override_database'),
5823            password=d.get('password'),
5824            port=d.get('port'),
5825            port_override=d.get('port_override'),
5826            secret_store_id=d.get('secret_store_id'),
5827            tags=d.get('tags'),
5828            username=d.get('username'),
5829        )
class HTTPAuth:
5832class HTTPAuth:
5833    '''
5834
5835    '''
5836    __slots__ = [
5837        'auth_header',
5838        'bind_interface',
5839        'default_path',
5840        'egress_filter',
5841        'headers_blacklist',
5842        'healthcheck_path',
5843        'healthy',
5844        'id',
5845        'name',
5846        'secret_store_id',
5847        'subdomain',
5848        'tags',
5849        'url',
5850    ]
5851
5852    def __init__(
5853        self,
5854        auth_header=None,
5855        bind_interface=None,
5856        default_path=None,
5857        egress_filter=None,
5858        headers_blacklist=None,
5859        healthcheck_path=None,
5860        healthy=None,
5861        id=None,
5862        name=None,
5863        secret_store_id=None,
5864        subdomain=None,
5865        tags=None,
5866        url=None,
5867    ):
5868        self.auth_header = auth_header if auth_header is not None else ''
5869        '''
5870
5871        '''
5872        self.bind_interface = bind_interface if bind_interface is not None else ''
5873        '''
5874         Bind interface
5875        '''
5876        self.default_path = default_path if default_path is not None else ''
5877        '''
5878
5879        '''
5880        self.egress_filter = egress_filter if egress_filter is not None else ''
5881        '''
5882         A filter applied to the routing logic to pin datasource to nodes.
5883        '''
5884        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5885        '''
5886
5887        '''
5888        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5889        '''
5890
5891        '''
5892        self.healthy = healthy if healthy is not None else False
5893        '''
5894         True if the datasource is reachable and the credentials are valid.
5895        '''
5896        self.id = id if id is not None else ''
5897        '''
5898         Unique identifier of the Resource.
5899        '''
5900        self.name = name if name is not None else ''
5901        '''
5902         Unique human-readable name of the Resource.
5903        '''
5904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5905        '''
5906         ID of the secret store containing credentials for this resource, if any.
5907        '''
5908        self.subdomain = subdomain if subdomain is not None else ''
5909        '''
5910
5911        '''
5912        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5913        '''
5914         Tags is a map of key, value pairs.
5915        '''
5916        self.url = url if url is not None else ''
5917        '''
5918
5919        '''
5920
5921    def __repr__(self):
5922        return '<sdm.HTTPAuth ' + \
5923            'auth_header: ' + repr(self.auth_header) + ' ' +\
5924            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5925            'default_path: ' + repr(self.default_path) + ' ' +\
5926            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5927            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5928            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5929            'healthy: ' + repr(self.healthy) + ' ' +\
5930            'id: ' + repr(self.id) + ' ' +\
5931            'name: ' + repr(self.name) + ' ' +\
5932            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5933            'subdomain: ' + repr(self.subdomain) + ' ' +\
5934            'tags: ' + repr(self.tags) + ' ' +\
5935            'url: ' + repr(self.url) + ' ' +\
5936            '>'
5937
5938    def to_dict(self):
5939        return {
5940            'auth_header': self.auth_header,
5941            'bind_interface': self.bind_interface,
5942            'default_path': self.default_path,
5943            'egress_filter': self.egress_filter,
5944            'headers_blacklist': self.headers_blacklist,
5945            'healthcheck_path': self.healthcheck_path,
5946            'healthy': self.healthy,
5947            'id': self.id,
5948            'name': self.name,
5949            'secret_store_id': self.secret_store_id,
5950            'subdomain': self.subdomain,
5951            'tags': self.tags,
5952            'url': self.url,
5953        }
5954
5955    @classmethod
5956    def from_dict(cls, d):
5957        return cls(
5958            auth_header=d.get('auth_header'),
5959            bind_interface=d.get('bind_interface'),
5960            default_path=d.get('default_path'),
5961            egress_filter=d.get('egress_filter'),
5962            headers_blacklist=d.get('headers_blacklist'),
5963            healthcheck_path=d.get('healthcheck_path'),
5964            healthy=d.get('healthy'),
5965            id=d.get('id'),
5966            name=d.get('name'),
5967            secret_store_id=d.get('secret_store_id'),
5968            subdomain=d.get('subdomain'),
5969            tags=d.get('tags'),
5970            url=d.get('url'),
5971        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5852    def __init__(
5853        self,
5854        auth_header=None,
5855        bind_interface=None,
5856        default_path=None,
5857        egress_filter=None,
5858        headers_blacklist=None,
5859        healthcheck_path=None,
5860        healthy=None,
5861        id=None,
5862        name=None,
5863        secret_store_id=None,
5864        subdomain=None,
5865        tags=None,
5866        url=None,
5867    ):
5868        self.auth_header = auth_header if auth_header is not None else ''
5869        '''
5870
5871        '''
5872        self.bind_interface = bind_interface if bind_interface is not None else ''
5873        '''
5874         Bind interface
5875        '''
5876        self.default_path = default_path if default_path is not None else ''
5877        '''
5878
5879        '''
5880        self.egress_filter = egress_filter if egress_filter is not None else ''
5881        '''
5882         A filter applied to the routing logic to pin datasource to nodes.
5883        '''
5884        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5885        '''
5886
5887        '''
5888        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5889        '''
5890
5891        '''
5892        self.healthy = healthy if healthy is not None else False
5893        '''
5894         True if the datasource is reachable and the credentials are valid.
5895        '''
5896        self.id = id if id is not None else ''
5897        '''
5898         Unique identifier of the Resource.
5899        '''
5900        self.name = name if name is not None else ''
5901        '''
5902         Unique human-readable name of the Resource.
5903        '''
5904        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5905        '''
5906         ID of the secret store containing credentials for this resource, if any.
5907        '''
5908        self.subdomain = subdomain if subdomain is not None else ''
5909        '''
5910
5911        '''
5912        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5913        '''
5914         Tags is a map of key, value pairs.
5915        '''
5916        self.url = url if url is not None else ''
5917        '''
5918
5919        '''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5938    def to_dict(self):
5939        return {
5940            'auth_header': self.auth_header,
5941            'bind_interface': self.bind_interface,
5942            'default_path': self.default_path,
5943            'egress_filter': self.egress_filter,
5944            'headers_blacklist': self.headers_blacklist,
5945            'healthcheck_path': self.healthcheck_path,
5946            'healthy': self.healthy,
5947            'id': self.id,
5948            'name': self.name,
5949            'secret_store_id': self.secret_store_id,
5950            'subdomain': self.subdomain,
5951            'tags': self.tags,
5952            'url': self.url,
5953        }
@classmethod
def from_dict(cls, d)
5955    @classmethod
5956    def from_dict(cls, d):
5957        return cls(
5958            auth_header=d.get('auth_header'),
5959            bind_interface=d.get('bind_interface'),
5960            default_path=d.get('default_path'),
5961            egress_filter=d.get('egress_filter'),
5962            headers_blacklist=d.get('headers_blacklist'),
5963            healthcheck_path=d.get('healthcheck_path'),
5964            healthy=d.get('healthy'),
5965            id=d.get('id'),
5966            name=d.get('name'),
5967            secret_store_id=d.get('secret_store_id'),
5968            subdomain=d.get('subdomain'),
5969            tags=d.get('tags'),
5970            url=d.get('url'),
5971        )
class HTTPBasicAuth:
5974class HTTPBasicAuth:
5975    '''
5976
5977    '''
5978    __slots__ = [
5979        'bind_interface',
5980        'default_path',
5981        'egress_filter',
5982        'headers_blacklist',
5983        'healthcheck_path',
5984        'healthy',
5985        'id',
5986        'name',
5987        'password',
5988        'secret_store_id',
5989        'subdomain',
5990        'tags',
5991        'url',
5992        'username',
5993    ]
5994
5995    def __init__(
5996        self,
5997        bind_interface=None,
5998        default_path=None,
5999        egress_filter=None,
6000        headers_blacklist=None,
6001        healthcheck_path=None,
6002        healthy=None,
6003        id=None,
6004        name=None,
6005        password=None,
6006        secret_store_id=None,
6007        subdomain=None,
6008        tags=None,
6009        url=None,
6010        username=None,
6011    ):
6012        self.bind_interface = bind_interface if bind_interface is not None else ''
6013        '''
6014         Bind interface
6015        '''
6016        self.default_path = default_path if default_path is not None else ''
6017        '''
6018
6019        '''
6020        self.egress_filter = egress_filter if egress_filter is not None else ''
6021        '''
6022         A filter applied to the routing logic to pin datasource to nodes.
6023        '''
6024        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6025        '''
6026
6027        '''
6028        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6029        '''
6030
6031        '''
6032        self.healthy = healthy if healthy is not None else False
6033        '''
6034         True if the datasource is reachable and the credentials are valid.
6035        '''
6036        self.id = id if id is not None else ''
6037        '''
6038         Unique identifier of the Resource.
6039        '''
6040        self.name = name if name is not None else ''
6041        '''
6042         Unique human-readable name of the Resource.
6043        '''
6044        self.password = password if password is not None else ''
6045        '''
6046
6047        '''
6048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6049        '''
6050         ID of the secret store containing credentials for this resource, if any.
6051        '''
6052        self.subdomain = subdomain if subdomain is not None else ''
6053        '''
6054
6055        '''
6056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6057        '''
6058         Tags is a map of key, value pairs.
6059        '''
6060        self.url = url if url is not None else ''
6061        '''
6062
6063        '''
6064        self.username = username if username is not None else ''
6065        '''
6066
6067        '''
6068
6069    def __repr__(self):
6070        return '<sdm.HTTPBasicAuth ' + \
6071            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6072            'default_path: ' + repr(self.default_path) + ' ' +\
6073            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6074            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6075            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6076            'healthy: ' + repr(self.healthy) + ' ' +\
6077            'id: ' + repr(self.id) + ' ' +\
6078            'name: ' + repr(self.name) + ' ' +\
6079            'password: ' + repr(self.password) + ' ' +\
6080            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6081            'subdomain: ' + repr(self.subdomain) + ' ' +\
6082            'tags: ' + repr(self.tags) + ' ' +\
6083            'url: ' + repr(self.url) + ' ' +\
6084            'username: ' + repr(self.username) + ' ' +\
6085            '>'
6086
6087    def to_dict(self):
6088        return {
6089            'bind_interface': self.bind_interface,
6090            'default_path': self.default_path,
6091            'egress_filter': self.egress_filter,
6092            'headers_blacklist': self.headers_blacklist,
6093            'healthcheck_path': self.healthcheck_path,
6094            'healthy': self.healthy,
6095            'id': self.id,
6096            'name': self.name,
6097            'password': self.password,
6098            'secret_store_id': self.secret_store_id,
6099            'subdomain': self.subdomain,
6100            'tags': self.tags,
6101            'url': self.url,
6102            'username': self.username,
6103        }
6104
6105    @classmethod
6106    def from_dict(cls, d):
6107        return cls(
6108            bind_interface=d.get('bind_interface'),
6109            default_path=d.get('default_path'),
6110            egress_filter=d.get('egress_filter'),
6111            headers_blacklist=d.get('headers_blacklist'),
6112            healthcheck_path=d.get('healthcheck_path'),
6113            healthy=d.get('healthy'),
6114            id=d.get('id'),
6115            name=d.get('name'),
6116            password=d.get('password'),
6117            secret_store_id=d.get('secret_store_id'),
6118            subdomain=d.get('subdomain'),
6119            tags=d.get('tags'),
6120            url=d.get('url'),
6121            username=d.get('username'),
6122        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5995    def __init__(
5996        self,
5997        bind_interface=None,
5998        default_path=None,
5999        egress_filter=None,
6000        headers_blacklist=None,
6001        healthcheck_path=None,
6002        healthy=None,
6003        id=None,
6004        name=None,
6005        password=None,
6006        secret_store_id=None,
6007        subdomain=None,
6008        tags=None,
6009        url=None,
6010        username=None,
6011    ):
6012        self.bind_interface = bind_interface if bind_interface is not None else ''
6013        '''
6014         Bind interface
6015        '''
6016        self.default_path = default_path if default_path is not None else ''
6017        '''
6018
6019        '''
6020        self.egress_filter = egress_filter if egress_filter is not None else ''
6021        '''
6022         A filter applied to the routing logic to pin datasource to nodes.
6023        '''
6024        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6025        '''
6026
6027        '''
6028        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6029        '''
6030
6031        '''
6032        self.healthy = healthy if healthy is not None else False
6033        '''
6034         True if the datasource is reachable and the credentials are valid.
6035        '''
6036        self.id = id if id is not None else ''
6037        '''
6038         Unique identifier of the Resource.
6039        '''
6040        self.name = name if name is not None else ''
6041        '''
6042         Unique human-readable name of the Resource.
6043        '''
6044        self.password = password if password is not None else ''
6045        '''
6046
6047        '''
6048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6049        '''
6050         ID of the secret store containing credentials for this resource, if any.
6051        '''
6052        self.subdomain = subdomain if subdomain is not None else ''
6053        '''
6054
6055        '''
6056        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6057        '''
6058         Tags is a map of key, value pairs.
6059        '''
6060        self.url = url if url is not None else ''
6061        '''
6062
6063        '''
6064        self.username = username if username is not None else ''
6065        '''
6066
6067        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
6087    def to_dict(self):
6088        return {
6089            'bind_interface': self.bind_interface,
6090            'default_path': self.default_path,
6091            'egress_filter': self.egress_filter,
6092            'headers_blacklist': self.headers_blacklist,
6093            'healthcheck_path': self.healthcheck_path,
6094            'healthy': self.healthy,
6095            'id': self.id,
6096            'name': self.name,
6097            'password': self.password,
6098            'secret_store_id': self.secret_store_id,
6099            'subdomain': self.subdomain,
6100            'tags': self.tags,
6101            'url': self.url,
6102            'username': self.username,
6103        }
@classmethod
def from_dict(cls, d)
6105    @classmethod
6106    def from_dict(cls, d):
6107        return cls(
6108            bind_interface=d.get('bind_interface'),
6109            default_path=d.get('default_path'),
6110            egress_filter=d.get('egress_filter'),
6111            headers_blacklist=d.get('headers_blacklist'),
6112            healthcheck_path=d.get('healthcheck_path'),
6113            healthy=d.get('healthy'),
6114            id=d.get('id'),
6115            name=d.get('name'),
6116            password=d.get('password'),
6117            secret_store_id=d.get('secret_store_id'),
6118            subdomain=d.get('subdomain'),
6119            tags=d.get('tags'),
6120            url=d.get('url'),
6121            username=d.get('username'),
6122        )
class HTTPNoAuth:
6125class HTTPNoAuth:
6126    '''
6127
6128    '''
6129    __slots__ = [
6130        'bind_interface',
6131        'default_path',
6132        'egress_filter',
6133        'headers_blacklist',
6134        'healthcheck_path',
6135        'healthy',
6136        'id',
6137        'name',
6138        'secret_store_id',
6139        'subdomain',
6140        'tags',
6141        'url',
6142    ]
6143
6144    def __init__(
6145        self,
6146        bind_interface=None,
6147        default_path=None,
6148        egress_filter=None,
6149        headers_blacklist=None,
6150        healthcheck_path=None,
6151        healthy=None,
6152        id=None,
6153        name=None,
6154        secret_store_id=None,
6155        subdomain=None,
6156        tags=None,
6157        url=None,
6158    ):
6159        self.bind_interface = bind_interface if bind_interface is not None else ''
6160        '''
6161         Bind interface
6162        '''
6163        self.default_path = default_path if default_path is not None else ''
6164        '''
6165
6166        '''
6167        self.egress_filter = egress_filter if egress_filter is not None else ''
6168        '''
6169         A filter applied to the routing logic to pin datasource to nodes.
6170        '''
6171        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6172        '''
6173
6174        '''
6175        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6176        '''
6177
6178        '''
6179        self.healthy = healthy if healthy is not None else False
6180        '''
6181         True if the datasource is reachable and the credentials are valid.
6182        '''
6183        self.id = id if id is not None else ''
6184        '''
6185         Unique identifier of the Resource.
6186        '''
6187        self.name = name if name is not None else ''
6188        '''
6189         Unique human-readable name of the Resource.
6190        '''
6191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6192        '''
6193         ID of the secret store containing credentials for this resource, if any.
6194        '''
6195        self.subdomain = subdomain if subdomain is not None else ''
6196        '''
6197
6198        '''
6199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6200        '''
6201         Tags is a map of key, value pairs.
6202        '''
6203        self.url = url if url is not None else ''
6204        '''
6205
6206        '''
6207
6208    def __repr__(self):
6209        return '<sdm.HTTPNoAuth ' + \
6210            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6211            'default_path: ' + repr(self.default_path) + ' ' +\
6212            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6213            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6214            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6215            'healthy: ' + repr(self.healthy) + ' ' +\
6216            'id: ' + repr(self.id) + ' ' +\
6217            'name: ' + repr(self.name) + ' ' +\
6218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6219            'subdomain: ' + repr(self.subdomain) + ' ' +\
6220            'tags: ' + repr(self.tags) + ' ' +\
6221            'url: ' + repr(self.url) + ' ' +\
6222            '>'
6223
6224    def to_dict(self):
6225        return {
6226            'bind_interface': self.bind_interface,
6227            'default_path': self.default_path,
6228            'egress_filter': self.egress_filter,
6229            'headers_blacklist': self.headers_blacklist,
6230            'healthcheck_path': self.healthcheck_path,
6231            'healthy': self.healthy,
6232            'id': self.id,
6233            'name': self.name,
6234            'secret_store_id': self.secret_store_id,
6235            'subdomain': self.subdomain,
6236            'tags': self.tags,
6237            'url': self.url,
6238        }
6239
6240    @classmethod
6241    def from_dict(cls, d):
6242        return cls(
6243            bind_interface=d.get('bind_interface'),
6244            default_path=d.get('default_path'),
6245            egress_filter=d.get('egress_filter'),
6246            headers_blacklist=d.get('headers_blacklist'),
6247            healthcheck_path=d.get('healthcheck_path'),
6248            healthy=d.get('healthy'),
6249            id=d.get('id'),
6250            name=d.get('name'),
6251            secret_store_id=d.get('secret_store_id'),
6252            subdomain=d.get('subdomain'),
6253            tags=d.get('tags'),
6254            url=d.get('url'),
6255        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6144    def __init__(
6145        self,
6146        bind_interface=None,
6147        default_path=None,
6148        egress_filter=None,
6149        headers_blacklist=None,
6150        healthcheck_path=None,
6151        healthy=None,
6152        id=None,
6153        name=None,
6154        secret_store_id=None,
6155        subdomain=None,
6156        tags=None,
6157        url=None,
6158    ):
6159        self.bind_interface = bind_interface if bind_interface is not None else ''
6160        '''
6161         Bind interface
6162        '''
6163        self.default_path = default_path if default_path is not None else ''
6164        '''
6165
6166        '''
6167        self.egress_filter = egress_filter if egress_filter is not None else ''
6168        '''
6169         A filter applied to the routing logic to pin datasource to nodes.
6170        '''
6171        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6172        '''
6173
6174        '''
6175        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6176        '''
6177
6178        '''
6179        self.healthy = healthy if healthy is not None else False
6180        '''
6181         True if the datasource is reachable and the credentials are valid.
6182        '''
6183        self.id = id if id is not None else ''
6184        '''
6185         Unique identifier of the Resource.
6186        '''
6187        self.name = name if name is not None else ''
6188        '''
6189         Unique human-readable name of the Resource.
6190        '''
6191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6192        '''
6193         ID of the secret store containing credentials for this resource, if any.
6194        '''
6195        self.subdomain = subdomain if subdomain is not None else ''
6196        '''
6197
6198        '''
6199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6200        '''
6201         Tags is a map of key, value pairs.
6202        '''
6203        self.url = url if url is not None else ''
6204        '''
6205
6206        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6224    def to_dict(self):
6225        return {
6226            'bind_interface': self.bind_interface,
6227            'default_path': self.default_path,
6228            'egress_filter': self.egress_filter,
6229            'headers_blacklist': self.headers_blacklist,
6230            'healthcheck_path': self.healthcheck_path,
6231            'healthy': self.healthy,
6232            'id': self.id,
6233            'name': self.name,
6234            'secret_store_id': self.secret_store_id,
6235            'subdomain': self.subdomain,
6236            'tags': self.tags,
6237            'url': self.url,
6238        }
@classmethod
def from_dict(cls, d)
6240    @classmethod
6241    def from_dict(cls, d):
6242        return cls(
6243            bind_interface=d.get('bind_interface'),
6244            default_path=d.get('default_path'),
6245            egress_filter=d.get('egress_filter'),
6246            headers_blacklist=d.get('headers_blacklist'),
6247            healthcheck_path=d.get('healthcheck_path'),
6248            healthy=d.get('healthy'),
6249            id=d.get('id'),
6250            name=d.get('name'),
6251            secret_store_id=d.get('secret_store_id'),
6252            subdomain=d.get('subdomain'),
6253            tags=d.get('tags'),
6254            url=d.get('url'),
6255        )
class Kubernetes:
6258class Kubernetes:
6259    '''
6260
6261    '''
6262    __slots__ = [
6263        'bind_interface',
6264        'certificate_authority',
6265        'client_certificate',
6266        'client_key',
6267        'egress_filter',
6268        'healthcheck_namespace',
6269        'healthy',
6270        'hostname',
6271        'id',
6272        'name',
6273        'port',
6274        'port_override',
6275        'remote_identity_group_id',
6276        'remote_identity_healthcheck_username',
6277        'secret_store_id',
6278        'tags',
6279    ]
6280
6281    def __init__(
6282        self,
6283        bind_interface=None,
6284        certificate_authority=None,
6285        client_certificate=None,
6286        client_key=None,
6287        egress_filter=None,
6288        healthcheck_namespace=None,
6289        healthy=None,
6290        hostname=None,
6291        id=None,
6292        name=None,
6293        port=None,
6294        port_override=None,
6295        remote_identity_group_id=None,
6296        remote_identity_healthcheck_username=None,
6297        secret_store_id=None,
6298        tags=None,
6299    ):
6300        self.bind_interface = bind_interface if bind_interface is not None else ''
6301        '''
6302         Bind interface
6303        '''
6304        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6305        '''
6306
6307        '''
6308        self.client_certificate = client_certificate if client_certificate is not None else ''
6309        '''
6310
6311        '''
6312        self.client_key = client_key if client_key is not None else ''
6313        '''
6314
6315        '''
6316        self.egress_filter = egress_filter if egress_filter is not None else ''
6317        '''
6318         A filter applied to the routing logic to pin datasource to nodes.
6319        '''
6320        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6321        '''
6322         The path used to check the health of your connection.  Defaults to `default`.
6323        '''
6324        self.healthy = healthy if healthy is not None else False
6325        '''
6326         True if the datasource is reachable and the credentials are valid.
6327        '''
6328        self.hostname = hostname if hostname is not None else ''
6329        '''
6330
6331        '''
6332        self.id = id if id is not None else ''
6333        '''
6334         Unique identifier of the Resource.
6335        '''
6336        self.name = name if name is not None else ''
6337        '''
6338         Unique human-readable name of the Resource.
6339        '''
6340        self.port = port if port is not None else 0
6341        '''
6342
6343        '''
6344        self.port_override = port_override if port_override is not None else 0
6345        '''
6346
6347        '''
6348        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6349        '''
6350
6351        '''
6352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6353        '''
6354
6355        '''
6356        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6357        '''
6358         ID of the secret store containing credentials for this resource, if any.
6359        '''
6360        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6361        '''
6362         Tags is a map of key, value pairs.
6363        '''
6364
6365    def __repr__(self):
6366        return '<sdm.Kubernetes ' + \
6367            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6368            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6369            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6370            'client_key: ' + repr(self.client_key) + ' ' +\
6371            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6372            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6373            'healthy: ' + repr(self.healthy) + ' ' +\
6374            'hostname: ' + repr(self.hostname) + ' ' +\
6375            'id: ' + repr(self.id) + ' ' +\
6376            'name: ' + repr(self.name) + ' ' +\
6377            'port: ' + repr(self.port) + ' ' +\
6378            'port_override: ' + repr(self.port_override) + ' ' +\
6379            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6380            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6381            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6382            'tags: ' + repr(self.tags) + ' ' +\
6383            '>'
6384
6385    def to_dict(self):
6386        return {
6387            'bind_interface': self.bind_interface,
6388            'certificate_authority': self.certificate_authority,
6389            'client_certificate': self.client_certificate,
6390            'client_key': self.client_key,
6391            'egress_filter': self.egress_filter,
6392            'healthcheck_namespace': self.healthcheck_namespace,
6393            'healthy': self.healthy,
6394            'hostname': self.hostname,
6395            'id': self.id,
6396            'name': self.name,
6397            'port': self.port,
6398            'port_override': self.port_override,
6399            'remote_identity_group_id': self.remote_identity_group_id,
6400            'remote_identity_healthcheck_username':
6401            self.remote_identity_healthcheck_username,
6402            'secret_store_id': self.secret_store_id,
6403            'tags': self.tags,
6404        }
6405
6406    @classmethod
6407    def from_dict(cls, d):
6408        return cls(
6409            bind_interface=d.get('bind_interface'),
6410            certificate_authority=d.get('certificate_authority'),
6411            client_certificate=d.get('client_certificate'),
6412            client_key=d.get('client_key'),
6413            egress_filter=d.get('egress_filter'),
6414            healthcheck_namespace=d.get('healthcheck_namespace'),
6415            healthy=d.get('healthy'),
6416            hostname=d.get('hostname'),
6417            id=d.get('id'),
6418            name=d.get('name'),
6419            port=d.get('port'),
6420            port_override=d.get('port_override'),
6421            remote_identity_group_id=d.get('remote_identity_group_id'),
6422            remote_identity_healthcheck_username=d.get(
6423                'remote_identity_healthcheck_username'),
6424            secret_store_id=d.get('secret_store_id'),
6425            tags=d.get('tags'),
6426        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6281    def __init__(
6282        self,
6283        bind_interface=None,
6284        certificate_authority=None,
6285        client_certificate=None,
6286        client_key=None,
6287        egress_filter=None,
6288        healthcheck_namespace=None,
6289        healthy=None,
6290        hostname=None,
6291        id=None,
6292        name=None,
6293        port=None,
6294        port_override=None,
6295        remote_identity_group_id=None,
6296        remote_identity_healthcheck_username=None,
6297        secret_store_id=None,
6298        tags=None,
6299    ):
6300        self.bind_interface = bind_interface if bind_interface is not None else ''
6301        '''
6302         Bind interface
6303        '''
6304        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6305        '''
6306
6307        '''
6308        self.client_certificate = client_certificate if client_certificate is not None else ''
6309        '''
6310
6311        '''
6312        self.client_key = client_key if client_key is not None else ''
6313        '''
6314
6315        '''
6316        self.egress_filter = egress_filter if egress_filter is not None else ''
6317        '''
6318         A filter applied to the routing logic to pin datasource to nodes.
6319        '''
6320        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6321        '''
6322         The path used to check the health of your connection.  Defaults to `default`.
6323        '''
6324        self.healthy = healthy if healthy is not None else False
6325        '''
6326         True if the datasource is reachable and the credentials are valid.
6327        '''
6328        self.hostname = hostname if hostname is not None else ''
6329        '''
6330
6331        '''
6332        self.id = id if id is not None else ''
6333        '''
6334         Unique identifier of the Resource.
6335        '''
6336        self.name = name if name is not None else ''
6337        '''
6338         Unique human-readable name of the Resource.
6339        '''
6340        self.port = port if port is not None else 0
6341        '''
6342
6343        '''
6344        self.port_override = port_override if port_override is not None else 0
6345        '''
6346
6347        '''
6348        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6349        '''
6350
6351        '''
6352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6353        '''
6354
6355        '''
6356        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6357        '''
6358         ID of the secret store containing credentials for this resource, if any.
6359        '''
6360        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6361        '''
6362         Tags is a map of key, value pairs.
6363        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6385    def to_dict(self):
6386        return {
6387            'bind_interface': self.bind_interface,
6388            'certificate_authority': self.certificate_authority,
6389            'client_certificate': self.client_certificate,
6390            'client_key': self.client_key,
6391            'egress_filter': self.egress_filter,
6392            'healthcheck_namespace': self.healthcheck_namespace,
6393            'healthy': self.healthy,
6394            'hostname': self.hostname,
6395            'id': self.id,
6396            'name': self.name,
6397            'port': self.port,
6398            'port_override': self.port_override,
6399            'remote_identity_group_id': self.remote_identity_group_id,
6400            'remote_identity_healthcheck_username':
6401            self.remote_identity_healthcheck_username,
6402            'secret_store_id': self.secret_store_id,
6403            'tags': self.tags,
6404        }
@classmethod
def from_dict(cls, d)
6406    @classmethod
6407    def from_dict(cls, d):
6408        return cls(
6409            bind_interface=d.get('bind_interface'),
6410            certificate_authority=d.get('certificate_authority'),
6411            client_certificate=d.get('client_certificate'),
6412            client_key=d.get('client_key'),
6413            egress_filter=d.get('egress_filter'),
6414            healthcheck_namespace=d.get('healthcheck_namespace'),
6415            healthy=d.get('healthy'),
6416            hostname=d.get('hostname'),
6417            id=d.get('id'),
6418            name=d.get('name'),
6419            port=d.get('port'),
6420            port_override=d.get('port_override'),
6421            remote_identity_group_id=d.get('remote_identity_group_id'),
6422            remote_identity_healthcheck_username=d.get(
6423                'remote_identity_healthcheck_username'),
6424            secret_store_id=d.get('secret_store_id'),
6425            tags=d.get('tags'),
6426        )
class KubernetesBasicAuth:
6429class KubernetesBasicAuth:
6430    '''
6431
6432    '''
6433    __slots__ = [
6434        'bind_interface',
6435        'egress_filter',
6436        'healthcheck_namespace',
6437        'healthy',
6438        'hostname',
6439        'id',
6440        'name',
6441        'password',
6442        'port',
6443        'port_override',
6444        'secret_store_id',
6445        'tags',
6446        'username',
6447    ]
6448
6449    def __init__(
6450        self,
6451        bind_interface=None,
6452        egress_filter=None,
6453        healthcheck_namespace=None,
6454        healthy=None,
6455        hostname=None,
6456        id=None,
6457        name=None,
6458        password=None,
6459        port=None,
6460        port_override=None,
6461        secret_store_id=None,
6462        tags=None,
6463        username=None,
6464    ):
6465        self.bind_interface = bind_interface if bind_interface is not None else ''
6466        '''
6467         Bind interface
6468        '''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6474        '''
6475         The path used to check the health of your connection.  Defaults to `default`.
6476        '''
6477        self.healthy = healthy if healthy is not None else False
6478        '''
6479         True if the datasource is reachable and the credentials are valid.
6480        '''
6481        self.hostname = hostname if hostname is not None else ''
6482        '''
6483
6484        '''
6485        self.id = id if id is not None else ''
6486        '''
6487         Unique identifier of the Resource.
6488        '''
6489        self.name = name if name is not None else ''
6490        '''
6491         Unique human-readable name of the Resource.
6492        '''
6493        self.password = password if password is not None else ''
6494        '''
6495
6496        '''
6497        self.port = port if port is not None else 0
6498        '''
6499
6500        '''
6501        self.port_override = port_override if port_override is not None else 0
6502        '''
6503
6504        '''
6505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6506        '''
6507         ID of the secret store containing credentials for this resource, if any.
6508        '''
6509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6510        '''
6511         Tags is a map of key, value pairs.
6512        '''
6513        self.username = username if username is not None else ''
6514        '''
6515
6516        '''
6517
6518    def __repr__(self):
6519        return '<sdm.KubernetesBasicAuth ' + \
6520            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6521            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6522            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6523            'healthy: ' + repr(self.healthy) + ' ' +\
6524            'hostname: ' + repr(self.hostname) + ' ' +\
6525            'id: ' + repr(self.id) + ' ' +\
6526            'name: ' + repr(self.name) + ' ' +\
6527            'password: ' + repr(self.password) + ' ' +\
6528            'port: ' + repr(self.port) + ' ' +\
6529            'port_override: ' + repr(self.port_override) + ' ' +\
6530            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6531            'tags: ' + repr(self.tags) + ' ' +\
6532            'username: ' + repr(self.username) + ' ' +\
6533            '>'
6534
6535    def to_dict(self):
6536        return {
6537            'bind_interface': self.bind_interface,
6538            'egress_filter': self.egress_filter,
6539            'healthcheck_namespace': self.healthcheck_namespace,
6540            'healthy': self.healthy,
6541            'hostname': self.hostname,
6542            'id': self.id,
6543            'name': self.name,
6544            'password': self.password,
6545            'port': self.port,
6546            'port_override': self.port_override,
6547            'secret_store_id': self.secret_store_id,
6548            'tags': self.tags,
6549            'username': self.username,
6550        }
6551
6552    @classmethod
6553    def from_dict(cls, d):
6554        return cls(
6555            bind_interface=d.get('bind_interface'),
6556            egress_filter=d.get('egress_filter'),
6557            healthcheck_namespace=d.get('healthcheck_namespace'),
6558            healthy=d.get('healthy'),
6559            hostname=d.get('hostname'),
6560            id=d.get('id'),
6561            name=d.get('name'),
6562            password=d.get('password'),
6563            port=d.get('port'),
6564            port_override=d.get('port_override'),
6565            secret_store_id=d.get('secret_store_id'),
6566            tags=d.get('tags'),
6567            username=d.get('username'),
6568        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6449    def __init__(
6450        self,
6451        bind_interface=None,
6452        egress_filter=None,
6453        healthcheck_namespace=None,
6454        healthy=None,
6455        hostname=None,
6456        id=None,
6457        name=None,
6458        password=None,
6459        port=None,
6460        port_override=None,
6461        secret_store_id=None,
6462        tags=None,
6463        username=None,
6464    ):
6465        self.bind_interface = bind_interface if bind_interface is not None else ''
6466        '''
6467         Bind interface
6468        '''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6474        '''
6475         The path used to check the health of your connection.  Defaults to `default`.
6476        '''
6477        self.healthy = healthy if healthy is not None else False
6478        '''
6479         True if the datasource is reachable and the credentials are valid.
6480        '''
6481        self.hostname = hostname if hostname is not None else ''
6482        '''
6483
6484        '''
6485        self.id = id if id is not None else ''
6486        '''
6487         Unique identifier of the Resource.
6488        '''
6489        self.name = name if name is not None else ''
6490        '''
6491         Unique human-readable name of the Resource.
6492        '''
6493        self.password = password if password is not None else ''
6494        '''
6495
6496        '''
6497        self.port = port if port is not None else 0
6498        '''
6499
6500        '''
6501        self.port_override = port_override if port_override is not None else 0
6502        '''
6503
6504        '''
6505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6506        '''
6507         ID of the secret store containing credentials for this resource, if any.
6508        '''
6509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6510        '''
6511         Tags is a map of key, value pairs.
6512        '''
6513        self.username = username if username is not None else ''
6514        '''
6515
6516        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6535    def to_dict(self):
6536        return {
6537            'bind_interface': self.bind_interface,
6538            'egress_filter': self.egress_filter,
6539            'healthcheck_namespace': self.healthcheck_namespace,
6540            'healthy': self.healthy,
6541            'hostname': self.hostname,
6542            'id': self.id,
6543            'name': self.name,
6544            'password': self.password,
6545            'port': self.port,
6546            'port_override': self.port_override,
6547            'secret_store_id': self.secret_store_id,
6548            'tags': self.tags,
6549            'username': self.username,
6550        }
@classmethod
def from_dict(cls, d)
6552    @classmethod
6553    def from_dict(cls, d):
6554        return cls(
6555            bind_interface=d.get('bind_interface'),
6556            egress_filter=d.get('egress_filter'),
6557            healthcheck_namespace=d.get('healthcheck_namespace'),
6558            healthy=d.get('healthy'),
6559            hostname=d.get('hostname'),
6560            id=d.get('id'),
6561            name=d.get('name'),
6562            password=d.get('password'),
6563            port=d.get('port'),
6564            port_override=d.get('port_override'),
6565            secret_store_id=d.get('secret_store_id'),
6566            tags=d.get('tags'),
6567            username=d.get('username'),
6568        )
class KubernetesServiceAccount:
6571class KubernetesServiceAccount:
6572    '''
6573
6574    '''
6575    __slots__ = [
6576        'bind_interface',
6577        'egress_filter',
6578        'healthcheck_namespace',
6579        'healthy',
6580        'hostname',
6581        'id',
6582        'name',
6583        'port',
6584        'port_override',
6585        'remote_identity_group_id',
6586        'remote_identity_healthcheck_username',
6587        'secret_store_id',
6588        'tags',
6589        'token',
6590    ]
6591
6592    def __init__(
6593        self,
6594        bind_interface=None,
6595        egress_filter=None,
6596        healthcheck_namespace=None,
6597        healthy=None,
6598        hostname=None,
6599        id=None,
6600        name=None,
6601        port=None,
6602        port_override=None,
6603        remote_identity_group_id=None,
6604        remote_identity_healthcheck_username=None,
6605        secret_store_id=None,
6606        tags=None,
6607        token=None,
6608    ):
6609        self.bind_interface = bind_interface if bind_interface is not None else ''
6610        '''
6611         Bind interface
6612        '''
6613        self.egress_filter = egress_filter if egress_filter is not None else ''
6614        '''
6615         A filter applied to the routing logic to pin datasource to nodes.
6616        '''
6617        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6618        '''
6619         The path used to check the health of your connection.  Defaults to `default`.
6620        '''
6621        self.healthy = healthy if healthy is not None else False
6622        '''
6623         True if the datasource is reachable and the credentials are valid.
6624        '''
6625        self.hostname = hostname if hostname is not None else ''
6626        '''
6627
6628        '''
6629        self.id = id if id is not None else ''
6630        '''
6631         Unique identifier of the Resource.
6632        '''
6633        self.name = name if name is not None else ''
6634        '''
6635         Unique human-readable name of the Resource.
6636        '''
6637        self.port = port if port is not None else 0
6638        '''
6639
6640        '''
6641        self.port_override = port_override if port_override is not None else 0
6642        '''
6643
6644        '''
6645        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6646        '''
6647
6648        '''
6649        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6650        '''
6651
6652        '''
6653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6654        '''
6655         ID of the secret store containing credentials for this resource, if any.
6656        '''
6657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6658        '''
6659         Tags is a map of key, value pairs.
6660        '''
6661        self.token = token if token is not None else ''
6662        '''
6663
6664        '''
6665
6666    def __repr__(self):
6667        return '<sdm.KubernetesServiceAccount ' + \
6668            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6669            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6670            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6671            'healthy: ' + repr(self.healthy) + ' ' +\
6672            'hostname: ' + repr(self.hostname) + ' ' +\
6673            'id: ' + repr(self.id) + ' ' +\
6674            'name: ' + repr(self.name) + ' ' +\
6675            'port: ' + repr(self.port) + ' ' +\
6676            'port_override: ' + repr(self.port_override) + ' ' +\
6677            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6678            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6679            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6680            'tags: ' + repr(self.tags) + ' ' +\
6681            'token: ' + repr(self.token) + ' ' +\
6682            '>'
6683
6684    def to_dict(self):
6685        return {
6686            'bind_interface': self.bind_interface,
6687            'egress_filter': self.egress_filter,
6688            'healthcheck_namespace': self.healthcheck_namespace,
6689            'healthy': self.healthy,
6690            'hostname': self.hostname,
6691            'id': self.id,
6692            'name': self.name,
6693            'port': self.port,
6694            'port_override': self.port_override,
6695            'remote_identity_group_id': self.remote_identity_group_id,
6696            'remote_identity_healthcheck_username':
6697            self.remote_identity_healthcheck_username,
6698            'secret_store_id': self.secret_store_id,
6699            'tags': self.tags,
6700            'token': self.token,
6701        }
6702
6703    @classmethod
6704    def from_dict(cls, d):
6705        return cls(
6706            bind_interface=d.get('bind_interface'),
6707            egress_filter=d.get('egress_filter'),
6708            healthcheck_namespace=d.get('healthcheck_namespace'),
6709            healthy=d.get('healthy'),
6710            hostname=d.get('hostname'),
6711            id=d.get('id'),
6712            name=d.get('name'),
6713            port=d.get('port'),
6714            port_override=d.get('port_override'),
6715            remote_identity_group_id=d.get('remote_identity_group_id'),
6716            remote_identity_healthcheck_username=d.get(
6717                'remote_identity_healthcheck_username'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6592    def __init__(
6593        self,
6594        bind_interface=None,
6595        egress_filter=None,
6596        healthcheck_namespace=None,
6597        healthy=None,
6598        hostname=None,
6599        id=None,
6600        name=None,
6601        port=None,
6602        port_override=None,
6603        remote_identity_group_id=None,
6604        remote_identity_healthcheck_username=None,
6605        secret_store_id=None,
6606        tags=None,
6607        token=None,
6608    ):
6609        self.bind_interface = bind_interface if bind_interface is not None else ''
6610        '''
6611         Bind interface
6612        '''
6613        self.egress_filter = egress_filter if egress_filter is not None else ''
6614        '''
6615         A filter applied to the routing logic to pin datasource to nodes.
6616        '''
6617        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6618        '''
6619         The path used to check the health of your connection.  Defaults to `default`.
6620        '''
6621        self.healthy = healthy if healthy is not None else False
6622        '''
6623         True if the datasource is reachable and the credentials are valid.
6624        '''
6625        self.hostname = hostname if hostname is not None else ''
6626        '''
6627
6628        '''
6629        self.id = id if id is not None else ''
6630        '''
6631         Unique identifier of the Resource.
6632        '''
6633        self.name = name if name is not None else ''
6634        '''
6635         Unique human-readable name of the Resource.
6636        '''
6637        self.port = port if port is not None else 0
6638        '''
6639
6640        '''
6641        self.port_override = port_override if port_override is not None else 0
6642        '''
6643
6644        '''
6645        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6646        '''
6647
6648        '''
6649        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6650        '''
6651
6652        '''
6653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6654        '''
6655         ID of the secret store containing credentials for this resource, if any.
6656        '''
6657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6658        '''
6659         Tags is a map of key, value pairs.
6660        '''
6661        self.token = token if token is not None else ''
6662        '''
6663
6664        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6684    def to_dict(self):
6685        return {
6686            'bind_interface': self.bind_interface,
6687            'egress_filter': self.egress_filter,
6688            'healthcheck_namespace': self.healthcheck_namespace,
6689            'healthy': self.healthy,
6690            'hostname': self.hostname,
6691            'id': self.id,
6692            'name': self.name,
6693            'port': self.port,
6694            'port_override': self.port_override,
6695            'remote_identity_group_id': self.remote_identity_group_id,
6696            'remote_identity_healthcheck_username':
6697            self.remote_identity_healthcheck_username,
6698            'secret_store_id': self.secret_store_id,
6699            'tags': self.tags,
6700            'token': self.token,
6701        }
@classmethod
def from_dict(cls, d)
6703    @classmethod
6704    def from_dict(cls, d):
6705        return cls(
6706            bind_interface=d.get('bind_interface'),
6707            egress_filter=d.get('egress_filter'),
6708            healthcheck_namespace=d.get('healthcheck_namespace'),
6709            healthy=d.get('healthy'),
6710            hostname=d.get('hostname'),
6711            id=d.get('id'),
6712            name=d.get('name'),
6713            port=d.get('port'),
6714            port_override=d.get('port_override'),
6715            remote_identity_group_id=d.get('remote_identity_group_id'),
6716            remote_identity_healthcheck_username=d.get(
6717                'remote_identity_healthcheck_username'),
6718            secret_store_id=d.get('secret_store_id'),
6719            tags=d.get('tags'),
6720            token=d.get('token'),
6721        )
class KubernetesServiceAccountUserImpersonation:
6724class KubernetesServiceAccountUserImpersonation:
6725    '''
6726
6727    '''
6728    __slots__ = [
6729        'bind_interface',
6730        'egress_filter',
6731        'healthcheck_namespace',
6732        'healthy',
6733        'hostname',
6734        'id',
6735        'name',
6736        'port',
6737        'port_override',
6738        'secret_store_id',
6739        'tags',
6740        'token',
6741    ]
6742
6743    def __init__(
6744        self,
6745        bind_interface=None,
6746        egress_filter=None,
6747        healthcheck_namespace=None,
6748        healthy=None,
6749        hostname=None,
6750        id=None,
6751        name=None,
6752        port=None,
6753        port_override=None,
6754        secret_store_id=None,
6755        tags=None,
6756        token=None,
6757    ):
6758        self.bind_interface = bind_interface if bind_interface is not None else ''
6759        '''
6760         Bind interface
6761        '''
6762        self.egress_filter = egress_filter if egress_filter is not None else ''
6763        '''
6764         A filter applied to the routing logic to pin datasource to nodes.
6765        '''
6766        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6767        '''
6768         The path used to check the health of your connection.  Defaults to `default`.
6769        '''
6770        self.healthy = healthy if healthy is not None else False
6771        '''
6772         True if the datasource is reachable and the credentials are valid.
6773        '''
6774        self.hostname = hostname if hostname is not None else ''
6775        '''
6776
6777        '''
6778        self.id = id if id is not None else ''
6779        '''
6780         Unique identifier of the Resource.
6781        '''
6782        self.name = name if name is not None else ''
6783        '''
6784         Unique human-readable name of the Resource.
6785        '''
6786        self.port = port if port is not None else 0
6787        '''
6788
6789        '''
6790        self.port_override = port_override if port_override is not None else 0
6791        '''
6792
6793        '''
6794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6795        '''
6796         ID of the secret store containing credentials for this resource, if any.
6797        '''
6798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6799        '''
6800         Tags is a map of key, value pairs.
6801        '''
6802        self.token = token if token is not None else ''
6803        '''
6804
6805        '''
6806
6807    def __repr__(self):
6808        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6809            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6810            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6811            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6812            'healthy: ' + repr(self.healthy) + ' ' +\
6813            'hostname: ' + repr(self.hostname) + ' ' +\
6814            'id: ' + repr(self.id) + ' ' +\
6815            'name: ' + repr(self.name) + ' ' +\
6816            'port: ' + repr(self.port) + ' ' +\
6817            'port_override: ' + repr(self.port_override) + ' ' +\
6818            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6819            'tags: ' + repr(self.tags) + ' ' +\
6820            'token: ' + repr(self.token) + ' ' +\
6821            '>'
6822
6823    def to_dict(self):
6824        return {
6825            'bind_interface': self.bind_interface,
6826            'egress_filter': self.egress_filter,
6827            'healthcheck_namespace': self.healthcheck_namespace,
6828            'healthy': self.healthy,
6829            'hostname': self.hostname,
6830            'id': self.id,
6831            'name': self.name,
6832            'port': self.port,
6833            'port_override': self.port_override,
6834            'secret_store_id': self.secret_store_id,
6835            'tags': self.tags,
6836            'token': self.token,
6837        }
6838
6839    @classmethod
6840    def from_dict(cls, d):
6841        return cls(
6842            bind_interface=d.get('bind_interface'),
6843            egress_filter=d.get('egress_filter'),
6844            healthcheck_namespace=d.get('healthcheck_namespace'),
6845            healthy=d.get('healthy'),
6846            hostname=d.get('hostname'),
6847            id=d.get('id'),
6848            name=d.get('name'),
6849            port=d.get('port'),
6850            port_override=d.get('port_override'),
6851            secret_store_id=d.get('secret_store_id'),
6852            tags=d.get('tags'),
6853            token=d.get('token'),
6854        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6743    def __init__(
6744        self,
6745        bind_interface=None,
6746        egress_filter=None,
6747        healthcheck_namespace=None,
6748        healthy=None,
6749        hostname=None,
6750        id=None,
6751        name=None,
6752        port=None,
6753        port_override=None,
6754        secret_store_id=None,
6755        tags=None,
6756        token=None,
6757    ):
6758        self.bind_interface = bind_interface if bind_interface is not None else ''
6759        '''
6760         Bind interface
6761        '''
6762        self.egress_filter = egress_filter if egress_filter is not None else ''
6763        '''
6764         A filter applied to the routing logic to pin datasource to nodes.
6765        '''
6766        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6767        '''
6768         The path used to check the health of your connection.  Defaults to `default`.
6769        '''
6770        self.healthy = healthy if healthy is not None else False
6771        '''
6772         True if the datasource is reachable and the credentials are valid.
6773        '''
6774        self.hostname = hostname if hostname is not None else ''
6775        '''
6776
6777        '''
6778        self.id = id if id is not None else ''
6779        '''
6780         Unique identifier of the Resource.
6781        '''
6782        self.name = name if name is not None else ''
6783        '''
6784         Unique human-readable name of the Resource.
6785        '''
6786        self.port = port if port is not None else 0
6787        '''
6788
6789        '''
6790        self.port_override = port_override if port_override is not None else 0
6791        '''
6792
6793        '''
6794        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6795        '''
6796         ID of the secret store containing credentials for this resource, if any.
6797        '''
6798        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6799        '''
6800         Tags is a map of key, value pairs.
6801        '''
6802        self.token = token if token is not None else ''
6803        '''
6804
6805        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6823    def to_dict(self):
6824        return {
6825            'bind_interface': self.bind_interface,
6826            'egress_filter': self.egress_filter,
6827            'healthcheck_namespace': self.healthcheck_namespace,
6828            'healthy': self.healthy,
6829            'hostname': self.hostname,
6830            'id': self.id,
6831            'name': self.name,
6832            'port': self.port,
6833            'port_override': self.port_override,
6834            'secret_store_id': self.secret_store_id,
6835            'tags': self.tags,
6836            'token': self.token,
6837        }
@classmethod
def from_dict(cls, d)
6839    @classmethod
6840    def from_dict(cls, d):
6841        return cls(
6842            bind_interface=d.get('bind_interface'),
6843            egress_filter=d.get('egress_filter'),
6844            healthcheck_namespace=d.get('healthcheck_namespace'),
6845            healthy=d.get('healthy'),
6846            hostname=d.get('hostname'),
6847            id=d.get('id'),
6848            name=d.get('name'),
6849            port=d.get('port'),
6850            port_override=d.get('port_override'),
6851            secret_store_id=d.get('secret_store_id'),
6852            tags=d.get('tags'),
6853            token=d.get('token'),
6854        )
class KubernetesUserImpersonation:
6857class KubernetesUserImpersonation:
6858    '''
6859
6860    '''
6861    __slots__ = [
6862        'bind_interface',
6863        'certificate_authority',
6864        'client_certificate',
6865        'client_key',
6866        'egress_filter',
6867        'healthcheck_namespace',
6868        'healthy',
6869        'hostname',
6870        'id',
6871        'name',
6872        'port',
6873        'port_override',
6874        'secret_store_id',
6875        'tags',
6876    ]
6877
6878    def __init__(
6879        self,
6880        bind_interface=None,
6881        certificate_authority=None,
6882        client_certificate=None,
6883        client_key=None,
6884        egress_filter=None,
6885        healthcheck_namespace=None,
6886        healthy=None,
6887        hostname=None,
6888        id=None,
6889        name=None,
6890        port=None,
6891        port_override=None,
6892        secret_store_id=None,
6893        tags=None,
6894    ):
6895        self.bind_interface = bind_interface if bind_interface is not None else ''
6896        '''
6897         Bind interface
6898        '''
6899        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6900        '''
6901
6902        '''
6903        self.client_certificate = client_certificate if client_certificate is not None else ''
6904        '''
6905
6906        '''
6907        self.client_key = client_key if client_key is not None else ''
6908        '''
6909
6910        '''
6911        self.egress_filter = egress_filter if egress_filter is not None else ''
6912        '''
6913         A filter applied to the routing logic to pin datasource to nodes.
6914        '''
6915        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6916        '''
6917         The path used to check the health of your connection.  Defaults to `default`.
6918        '''
6919        self.healthy = healthy if healthy is not None else False
6920        '''
6921         True if the datasource is reachable and the credentials are valid.
6922        '''
6923        self.hostname = hostname if hostname is not None else ''
6924        '''
6925
6926        '''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        '''
6937
6938        '''
6939        self.port_override = port_override if port_override is not None else 0
6940        '''
6941
6942        '''
6943        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6944        '''
6945         ID of the secret store containing credentials for this resource, if any.
6946        '''
6947        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6948        '''
6949         Tags is a map of key, value pairs.
6950        '''
6951
6952    def __repr__(self):
6953        return '<sdm.KubernetesUserImpersonation ' + \
6954            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6955            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6956            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6957            'client_key: ' + repr(self.client_key) + ' ' +\
6958            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6959            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6960            'healthy: ' + repr(self.healthy) + ' ' +\
6961            'hostname: ' + repr(self.hostname) + ' ' +\
6962            'id: ' + repr(self.id) + ' ' +\
6963            'name: ' + repr(self.name) + ' ' +\
6964            'port: ' + repr(self.port) + ' ' +\
6965            'port_override: ' + repr(self.port_override) + ' ' +\
6966            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6967            'tags: ' + repr(self.tags) + ' ' +\
6968            '>'
6969
6970    def to_dict(self):
6971        return {
6972            'bind_interface': self.bind_interface,
6973            'certificate_authority': self.certificate_authority,
6974            'client_certificate': self.client_certificate,
6975            'client_key': self.client_key,
6976            'egress_filter': self.egress_filter,
6977            'healthcheck_namespace': self.healthcheck_namespace,
6978            'healthy': self.healthy,
6979            'hostname': self.hostname,
6980            'id': self.id,
6981            'name': self.name,
6982            'port': self.port,
6983            'port_override': self.port_override,
6984            'secret_store_id': self.secret_store_id,
6985            'tags': self.tags,
6986        }
6987
6988    @classmethod
6989    def from_dict(cls, d):
6990        return cls(
6991            bind_interface=d.get('bind_interface'),
6992            certificate_authority=d.get('certificate_authority'),
6993            client_certificate=d.get('client_certificate'),
6994            client_key=d.get('client_key'),
6995            egress_filter=d.get('egress_filter'),
6996            healthcheck_namespace=d.get('healthcheck_namespace'),
6997            healthy=d.get('healthy'),
6998            hostname=d.get('hostname'),
6999            id=d.get('id'),
7000            name=d.get('name'),
7001            port=d.get('port'),
7002            port_override=d.get('port_override'),
7003            secret_store_id=d.get('secret_store_id'),
7004            tags=d.get('tags'),
7005        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6878    def __init__(
6879        self,
6880        bind_interface=None,
6881        certificate_authority=None,
6882        client_certificate=None,
6883        client_key=None,
6884        egress_filter=None,
6885        healthcheck_namespace=None,
6886        healthy=None,
6887        hostname=None,
6888        id=None,
6889        name=None,
6890        port=None,
6891        port_override=None,
6892        secret_store_id=None,
6893        tags=None,
6894    ):
6895        self.bind_interface = bind_interface if bind_interface is not None else ''
6896        '''
6897         Bind interface
6898        '''
6899        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6900        '''
6901
6902        '''
6903        self.client_certificate = client_certificate if client_certificate is not None else ''
6904        '''
6905
6906        '''
6907        self.client_key = client_key if client_key is not None else ''
6908        '''
6909
6910        '''
6911        self.egress_filter = egress_filter if egress_filter is not None else ''
6912        '''
6913         A filter applied to the routing logic to pin datasource to nodes.
6914        '''
6915        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6916        '''
6917         The path used to check the health of your connection.  Defaults to `default`.
6918        '''
6919        self.healthy = healthy if healthy is not None else False
6920        '''
6921         True if the datasource is reachable and the credentials are valid.
6922        '''
6923        self.hostname = hostname if hostname is not None else ''
6924        '''
6925
6926        '''
6927        self.id = id if id is not None else ''
6928        '''
6929         Unique identifier of the Resource.
6930        '''
6931        self.name = name if name is not None else ''
6932        '''
6933         Unique human-readable name of the Resource.
6934        '''
6935        self.port = port if port is not None else 0
6936        '''
6937
6938        '''
6939        self.port_override = port_override if port_override is not None else 0
6940        '''
6941
6942        '''
6943        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6944        '''
6945         ID of the secret store containing credentials for this resource, if any.
6946        '''
6947        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6948        '''
6949         Tags is a map of key, value pairs.
6950        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6970    def to_dict(self):
6971        return {
6972            'bind_interface': self.bind_interface,
6973            'certificate_authority': self.certificate_authority,
6974            'client_certificate': self.client_certificate,
6975            'client_key': self.client_key,
6976            'egress_filter': self.egress_filter,
6977            'healthcheck_namespace': self.healthcheck_namespace,
6978            'healthy': self.healthy,
6979            'hostname': self.hostname,
6980            'id': self.id,
6981            'name': self.name,
6982            'port': self.port,
6983            'port_override': self.port_override,
6984            'secret_store_id': self.secret_store_id,
6985            'tags': self.tags,
6986        }
@classmethod
def from_dict(cls, d)
6988    @classmethod
6989    def from_dict(cls, d):
6990        return cls(
6991            bind_interface=d.get('bind_interface'),
6992            certificate_authority=d.get('certificate_authority'),
6993            client_certificate=d.get('client_certificate'),
6994            client_key=d.get('client_key'),
6995            egress_filter=d.get('egress_filter'),
6996            healthcheck_namespace=d.get('healthcheck_namespace'),
6997            healthy=d.get('healthy'),
6998            hostname=d.get('hostname'),
6999            id=d.get('id'),
7000            name=d.get('name'),
7001            port=d.get('port'),
7002            port_override=d.get('port_override'),
7003            secret_store_id=d.get('secret_store_id'),
7004            tags=d.get('tags'),
7005        )
class MTLSMysql:
7008class MTLSMysql:
7009    '''
7010
7011    '''
7012    __slots__ = [
7013        'bind_interface',
7014        'certificate_authority',
7015        'client_certificate',
7016        'client_key',
7017        'database',
7018        'egress_filter',
7019        'healthy',
7020        'hostname',
7021        'id',
7022        'name',
7023        'password',
7024        'port',
7025        'port_override',
7026        'secret_store_id',
7027        'server_name',
7028        'tags',
7029        'username',
7030    ]
7031
7032    def __init__(
7033        self,
7034        bind_interface=None,
7035        certificate_authority=None,
7036        client_certificate=None,
7037        client_key=None,
7038        database=None,
7039        egress_filter=None,
7040        healthy=None,
7041        hostname=None,
7042        id=None,
7043        name=None,
7044        password=None,
7045        port=None,
7046        port_override=None,
7047        secret_store_id=None,
7048        server_name=None,
7049        tags=None,
7050        username=None,
7051    ):
7052        self.bind_interface = bind_interface if bind_interface is not None else ''
7053        '''
7054         Bind interface
7055        '''
7056        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7057        '''
7058
7059        '''
7060        self.client_certificate = client_certificate if client_certificate is not None else ''
7061        '''
7062
7063        '''
7064        self.client_key = client_key if client_key is not None else ''
7065        '''
7066
7067        '''
7068        self.database = database if database is not None else ''
7069        '''
7070
7071        '''
7072        self.egress_filter = egress_filter if egress_filter is not None else ''
7073        '''
7074         A filter applied to the routing logic to pin datasource to nodes.
7075        '''
7076        self.healthy = healthy if healthy is not None else False
7077        '''
7078         True if the datasource is reachable and the credentials are valid.
7079        '''
7080        self.hostname = hostname if hostname is not None else ''
7081        '''
7082
7083        '''
7084        self.id = id if id is not None else ''
7085        '''
7086         Unique identifier of the Resource.
7087        '''
7088        self.name = name if name is not None else ''
7089        '''
7090         Unique human-readable name of the Resource.
7091        '''
7092        self.password = password if password is not None else ''
7093        '''
7094
7095        '''
7096        self.port = port if port is not None else 0
7097        '''
7098
7099        '''
7100        self.port_override = port_override if port_override is not None else 0
7101        '''
7102
7103        '''
7104        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7105        '''
7106         ID of the secret store containing credentials for this resource, if any.
7107        '''
7108        self.server_name = server_name if server_name is not None else ''
7109        '''
7110
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.username = username if username is not None else ''
7117        '''
7118
7119        '''
7120
7121    def __repr__(self):
7122        return '<sdm.MTLSMysql ' + \
7123            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7124            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7125            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7126            'client_key: ' + repr(self.client_key) + ' ' +\
7127            'database: ' + repr(self.database) + ' ' +\
7128            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7129            'healthy: ' + repr(self.healthy) + ' ' +\
7130            'hostname: ' + repr(self.hostname) + ' ' +\
7131            'id: ' + repr(self.id) + ' ' +\
7132            'name: ' + repr(self.name) + ' ' +\
7133            'password: ' + repr(self.password) + ' ' +\
7134            'port: ' + repr(self.port) + ' ' +\
7135            'port_override: ' + repr(self.port_override) + ' ' +\
7136            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7137            'server_name: ' + repr(self.server_name) + ' ' +\
7138            'tags: ' + repr(self.tags) + ' ' +\
7139            'username: ' + repr(self.username) + ' ' +\
7140            '>'
7141
7142    def to_dict(self):
7143        return {
7144            'bind_interface': self.bind_interface,
7145            'certificate_authority': self.certificate_authority,
7146            'client_certificate': self.client_certificate,
7147            'client_key': self.client_key,
7148            'database': self.database,
7149            'egress_filter': self.egress_filter,
7150            'healthy': self.healthy,
7151            'hostname': self.hostname,
7152            'id': self.id,
7153            'name': self.name,
7154            'password': self.password,
7155            'port': self.port,
7156            'port_override': self.port_override,
7157            'secret_store_id': self.secret_store_id,
7158            'server_name': self.server_name,
7159            'tags': self.tags,
7160            'username': self.username,
7161        }
7162
7163    @classmethod
7164    def from_dict(cls, d):
7165        return cls(
7166            bind_interface=d.get('bind_interface'),
7167            certificate_authority=d.get('certificate_authority'),
7168            client_certificate=d.get('client_certificate'),
7169            client_key=d.get('client_key'),
7170            database=d.get('database'),
7171            egress_filter=d.get('egress_filter'),
7172            healthy=d.get('healthy'),
7173            hostname=d.get('hostname'),
7174            id=d.get('id'),
7175            name=d.get('name'),
7176            password=d.get('password'),
7177            port=d.get('port'),
7178            port_override=d.get('port_override'),
7179            secret_store_id=d.get('secret_store_id'),
7180            server_name=d.get('server_name'),
7181            tags=d.get('tags'),
7182            username=d.get('username'),
7183        )
MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7032    def __init__(
7033        self,
7034        bind_interface=None,
7035        certificate_authority=None,
7036        client_certificate=None,
7037        client_key=None,
7038        database=None,
7039        egress_filter=None,
7040        healthy=None,
7041        hostname=None,
7042        id=None,
7043        name=None,
7044        password=None,
7045        port=None,
7046        port_override=None,
7047        secret_store_id=None,
7048        server_name=None,
7049        tags=None,
7050        username=None,
7051    ):
7052        self.bind_interface = bind_interface if bind_interface is not None else ''
7053        '''
7054         Bind interface
7055        '''
7056        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7057        '''
7058
7059        '''
7060        self.client_certificate = client_certificate if client_certificate is not None else ''
7061        '''
7062
7063        '''
7064        self.client_key = client_key if client_key is not None else ''
7065        '''
7066
7067        '''
7068        self.database = database if database is not None else ''
7069        '''
7070
7071        '''
7072        self.egress_filter = egress_filter if egress_filter is not None else ''
7073        '''
7074         A filter applied to the routing logic to pin datasource to nodes.
7075        '''
7076        self.healthy = healthy if healthy is not None else False
7077        '''
7078         True if the datasource is reachable and the credentials are valid.
7079        '''
7080        self.hostname = hostname if hostname is not None else ''
7081        '''
7082
7083        '''
7084        self.id = id if id is not None else ''
7085        '''
7086         Unique identifier of the Resource.
7087        '''
7088        self.name = name if name is not None else ''
7089        '''
7090         Unique human-readable name of the Resource.
7091        '''
7092        self.password = password if password is not None else ''
7093        '''
7094
7095        '''
7096        self.port = port if port is not None else 0
7097        '''
7098
7099        '''
7100        self.port_override = port_override if port_override is not None else 0
7101        '''
7102
7103        '''
7104        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7105        '''
7106         ID of the secret store containing credentials for this resource, if any.
7107        '''
7108        self.server_name = server_name if server_name is not None else ''
7109        '''
7110
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.username = username if username is not None else ''
7117        '''
7118
7119        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7142    def to_dict(self):
7143        return {
7144            'bind_interface': self.bind_interface,
7145            'certificate_authority': self.certificate_authority,
7146            'client_certificate': self.client_certificate,
7147            'client_key': self.client_key,
7148            'database': self.database,
7149            'egress_filter': self.egress_filter,
7150            'healthy': self.healthy,
7151            'hostname': self.hostname,
7152            'id': self.id,
7153            'name': self.name,
7154            'password': self.password,
7155            'port': self.port,
7156            'port_override': self.port_override,
7157            'secret_store_id': self.secret_store_id,
7158            'server_name': self.server_name,
7159            'tags': self.tags,
7160            'username': self.username,
7161        }
@classmethod
def from_dict(cls, d)
7163    @classmethod
7164    def from_dict(cls, d):
7165        return cls(
7166            bind_interface=d.get('bind_interface'),
7167            certificate_authority=d.get('certificate_authority'),
7168            client_certificate=d.get('client_certificate'),
7169            client_key=d.get('client_key'),
7170            database=d.get('database'),
7171            egress_filter=d.get('egress_filter'),
7172            healthy=d.get('healthy'),
7173            hostname=d.get('hostname'),
7174            id=d.get('id'),
7175            name=d.get('name'),
7176            password=d.get('password'),
7177            port=d.get('port'),
7178            port_override=d.get('port_override'),
7179            secret_store_id=d.get('secret_store_id'),
7180            server_name=d.get('server_name'),
7181            tags=d.get('tags'),
7182            username=d.get('username'),
7183        )
class MTLSPostgres:
7186class MTLSPostgres:
7187    '''
7188
7189    '''
7190    __slots__ = [
7191        'bind_interface',
7192        'certificate_authority',
7193        'client_certificate',
7194        'client_key',
7195        'database',
7196        'egress_filter',
7197        'healthy',
7198        'hostname',
7199        'id',
7200        'name',
7201        'override_database',
7202        'password',
7203        'port',
7204        'port_override',
7205        'secret_store_id',
7206        'server_name',
7207        'tags',
7208        'username',
7209    ]
7210
7211    def __init__(
7212        self,
7213        bind_interface=None,
7214        certificate_authority=None,
7215        client_certificate=None,
7216        client_key=None,
7217        database=None,
7218        egress_filter=None,
7219        healthy=None,
7220        hostname=None,
7221        id=None,
7222        name=None,
7223        override_database=None,
7224        password=None,
7225        port=None,
7226        port_override=None,
7227        secret_store_id=None,
7228        server_name=None,
7229        tags=None,
7230        username=None,
7231    ):
7232        self.bind_interface = bind_interface if bind_interface is not None else ''
7233        '''
7234         Bind interface
7235        '''
7236        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7237        '''
7238
7239        '''
7240        self.client_certificate = client_certificate if client_certificate is not None else ''
7241        '''
7242
7243        '''
7244        self.client_key = client_key if client_key is not None else ''
7245        '''
7246
7247        '''
7248        self.database = database if database is not None else ''
7249        '''
7250
7251        '''
7252        self.egress_filter = egress_filter if egress_filter is not None else ''
7253        '''
7254         A filter applied to the routing logic to pin datasource to nodes.
7255        '''
7256        self.healthy = healthy if healthy is not None else False
7257        '''
7258         True if the datasource is reachable and the credentials are valid.
7259        '''
7260        self.hostname = hostname if hostname is not None else ''
7261        '''
7262
7263        '''
7264        self.id = id if id is not None else ''
7265        '''
7266         Unique identifier of the Resource.
7267        '''
7268        self.name = name if name is not None else ''
7269        '''
7270         Unique human-readable name of the Resource.
7271        '''
7272        self.override_database = override_database if override_database is not None else False
7273        '''
7274
7275        '''
7276        self.password = password if password is not None else ''
7277        '''
7278
7279        '''
7280        self.port = port if port is not None else 0
7281        '''
7282
7283        '''
7284        self.port_override = port_override if port_override is not None else 0
7285        '''
7286
7287        '''
7288        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7289        '''
7290         ID of the secret store containing credentials for this resource, if any.
7291        '''
7292        self.server_name = server_name if server_name is not None else ''
7293        '''
7294
7295        '''
7296        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7297        '''
7298         Tags is a map of key, value pairs.
7299        '''
7300        self.username = username if username is not None else ''
7301        '''
7302
7303        '''
7304
7305    def __repr__(self):
7306        return '<sdm.MTLSPostgres ' + \
7307            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7308            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7309            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7310            'client_key: ' + repr(self.client_key) + ' ' +\
7311            'database: ' + repr(self.database) + ' ' +\
7312            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7313            'healthy: ' + repr(self.healthy) + ' ' +\
7314            'hostname: ' + repr(self.hostname) + ' ' +\
7315            'id: ' + repr(self.id) + ' ' +\
7316            'name: ' + repr(self.name) + ' ' +\
7317            'override_database: ' + repr(self.override_database) + ' ' +\
7318            'password: ' + repr(self.password) + ' ' +\
7319            'port: ' + repr(self.port) + ' ' +\
7320            'port_override: ' + repr(self.port_override) + ' ' +\
7321            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7322            'server_name: ' + repr(self.server_name) + ' ' +\
7323            'tags: ' + repr(self.tags) + ' ' +\
7324            'username: ' + repr(self.username) + ' ' +\
7325            '>'
7326
7327    def to_dict(self):
7328        return {
7329            'bind_interface': self.bind_interface,
7330            'certificate_authority': self.certificate_authority,
7331            'client_certificate': self.client_certificate,
7332            'client_key': self.client_key,
7333            'database': self.database,
7334            'egress_filter': self.egress_filter,
7335            'healthy': self.healthy,
7336            'hostname': self.hostname,
7337            'id': self.id,
7338            'name': self.name,
7339            'override_database': self.override_database,
7340            'password': self.password,
7341            'port': self.port,
7342            'port_override': self.port_override,
7343            'secret_store_id': self.secret_store_id,
7344            'server_name': self.server_name,
7345            'tags': self.tags,
7346            'username': self.username,
7347        }
7348
7349    @classmethod
7350    def from_dict(cls, d):
7351        return cls(
7352            bind_interface=d.get('bind_interface'),
7353            certificate_authority=d.get('certificate_authority'),
7354            client_certificate=d.get('client_certificate'),
7355            client_key=d.get('client_key'),
7356            database=d.get('database'),
7357            egress_filter=d.get('egress_filter'),
7358            healthy=d.get('healthy'),
7359            hostname=d.get('hostname'),
7360            id=d.get('id'),
7361            name=d.get('name'),
7362            override_database=d.get('override_database'),
7363            password=d.get('password'),
7364            port=d.get('port'),
7365            port_override=d.get('port_override'),
7366            secret_store_id=d.get('secret_store_id'),
7367            server_name=d.get('server_name'),
7368            tags=d.get('tags'),
7369            username=d.get('username'),
7370        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7211    def __init__(
7212        self,
7213        bind_interface=None,
7214        certificate_authority=None,
7215        client_certificate=None,
7216        client_key=None,
7217        database=None,
7218        egress_filter=None,
7219        healthy=None,
7220        hostname=None,
7221        id=None,
7222        name=None,
7223        override_database=None,
7224        password=None,
7225        port=None,
7226        port_override=None,
7227        secret_store_id=None,
7228        server_name=None,
7229        tags=None,
7230        username=None,
7231    ):
7232        self.bind_interface = bind_interface if bind_interface is not None else ''
7233        '''
7234         Bind interface
7235        '''
7236        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7237        '''
7238
7239        '''
7240        self.client_certificate = client_certificate if client_certificate is not None else ''
7241        '''
7242
7243        '''
7244        self.client_key = client_key if client_key is not None else ''
7245        '''
7246
7247        '''
7248        self.database = database if database is not None else ''
7249        '''
7250
7251        '''
7252        self.egress_filter = egress_filter if egress_filter is not None else ''
7253        '''
7254         A filter applied to the routing logic to pin datasource to nodes.
7255        '''
7256        self.healthy = healthy if healthy is not None else False
7257        '''
7258         True if the datasource is reachable and the credentials are valid.
7259        '''
7260        self.hostname = hostname if hostname is not None else ''
7261        '''
7262
7263        '''
7264        self.id = id if id is not None else ''
7265        '''
7266         Unique identifier of the Resource.
7267        '''
7268        self.name = name if name is not None else ''
7269        '''
7270         Unique human-readable name of the Resource.
7271        '''
7272        self.override_database = override_database if override_database is not None else False
7273        '''
7274
7275        '''
7276        self.password = password if password is not None else ''
7277        '''
7278
7279        '''
7280        self.port = port if port is not None else 0
7281        '''
7282
7283        '''
7284        self.port_override = port_override if port_override is not None else 0
7285        '''
7286
7287        '''
7288        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7289        '''
7290         ID of the secret store containing credentials for this resource, if any.
7291        '''
7292        self.server_name = server_name if server_name is not None else ''
7293        '''
7294
7295        '''
7296        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7297        '''
7298         Tags is a map of key, value pairs.
7299        '''
7300        self.username = username if username is not None else ''
7301        '''
7302
7303        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7327    def to_dict(self):
7328        return {
7329            'bind_interface': self.bind_interface,
7330            'certificate_authority': self.certificate_authority,
7331            'client_certificate': self.client_certificate,
7332            'client_key': self.client_key,
7333            'database': self.database,
7334            'egress_filter': self.egress_filter,
7335            'healthy': self.healthy,
7336            'hostname': self.hostname,
7337            'id': self.id,
7338            'name': self.name,
7339            'override_database': self.override_database,
7340            'password': self.password,
7341            'port': self.port,
7342            'port_override': self.port_override,
7343            'secret_store_id': self.secret_store_id,
7344            'server_name': self.server_name,
7345            'tags': self.tags,
7346            'username': self.username,
7347        }
@classmethod
def from_dict(cls, d)
7349    @classmethod
7350    def from_dict(cls, d):
7351        return cls(
7352            bind_interface=d.get('bind_interface'),
7353            certificate_authority=d.get('certificate_authority'),
7354            client_certificate=d.get('client_certificate'),
7355            client_key=d.get('client_key'),
7356            database=d.get('database'),
7357            egress_filter=d.get('egress_filter'),
7358            healthy=d.get('healthy'),
7359            hostname=d.get('hostname'),
7360            id=d.get('id'),
7361            name=d.get('name'),
7362            override_database=d.get('override_database'),
7363            password=d.get('password'),
7364            port=d.get('port'),
7365            port_override=d.get('port_override'),
7366            secret_store_id=d.get('secret_store_id'),
7367            server_name=d.get('server_name'),
7368            tags=d.get('tags'),
7369            username=d.get('username'),
7370        )
class Maria:
7373class Maria:
7374    '''
7375
7376    '''
7377    __slots__ = [
7378        'bind_interface',
7379        'database',
7380        'egress_filter',
7381        'healthy',
7382        'hostname',
7383        'id',
7384        'name',
7385        'password',
7386        'port',
7387        'port_override',
7388        'secret_store_id',
7389        'tags',
7390        'username',
7391    ]
7392
7393    def __init__(
7394        self,
7395        bind_interface=None,
7396        database=None,
7397        egress_filter=None,
7398        healthy=None,
7399        hostname=None,
7400        id=None,
7401        name=None,
7402        password=None,
7403        port=None,
7404        port_override=None,
7405        secret_store_id=None,
7406        tags=None,
7407        username=None,
7408    ):
7409        self.bind_interface = bind_interface if bind_interface is not None else ''
7410        '''
7411         Bind interface
7412        '''
7413        self.database = database if database is not None else ''
7414        '''
7415
7416        '''
7417        self.egress_filter = egress_filter if egress_filter is not None else ''
7418        '''
7419         A filter applied to the routing logic to pin datasource to nodes.
7420        '''
7421        self.healthy = healthy if healthy is not None else False
7422        '''
7423         True if the datasource is reachable and the credentials are valid.
7424        '''
7425        self.hostname = hostname if hostname is not None else ''
7426        '''
7427
7428        '''
7429        self.id = id if id is not None else ''
7430        '''
7431         Unique identifier of the Resource.
7432        '''
7433        self.name = name if name is not None else ''
7434        '''
7435         Unique human-readable name of the Resource.
7436        '''
7437        self.password = password if password is not None else ''
7438        '''
7439
7440        '''
7441        self.port = port if port is not None else 0
7442        '''
7443
7444        '''
7445        self.port_override = port_override if port_override is not None else 0
7446        '''
7447
7448        '''
7449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7450        '''
7451         ID of the secret store containing credentials for this resource, if any.
7452        '''
7453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7454        '''
7455         Tags is a map of key, value pairs.
7456        '''
7457        self.username = username if username is not None else ''
7458        '''
7459
7460        '''
7461
7462    def __repr__(self):
7463        return '<sdm.Maria ' + \
7464            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7465            'database: ' + repr(self.database) + ' ' +\
7466            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7467            'healthy: ' + repr(self.healthy) + ' ' +\
7468            'hostname: ' + repr(self.hostname) + ' ' +\
7469            'id: ' + repr(self.id) + ' ' +\
7470            'name: ' + repr(self.name) + ' ' +\
7471            'password: ' + repr(self.password) + ' ' +\
7472            'port: ' + repr(self.port) + ' ' +\
7473            'port_override: ' + repr(self.port_override) + ' ' +\
7474            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7475            'tags: ' + repr(self.tags) + ' ' +\
7476            'username: ' + repr(self.username) + ' ' +\
7477            '>'
7478
7479    def to_dict(self):
7480        return {
7481            'bind_interface': self.bind_interface,
7482            'database': self.database,
7483            'egress_filter': self.egress_filter,
7484            'healthy': self.healthy,
7485            'hostname': self.hostname,
7486            'id': self.id,
7487            'name': self.name,
7488            'password': self.password,
7489            'port': self.port,
7490            'port_override': self.port_override,
7491            'secret_store_id': self.secret_store_id,
7492            'tags': self.tags,
7493            'username': self.username,
7494        }
7495
7496    @classmethod
7497    def from_dict(cls, d):
7498        return cls(
7499            bind_interface=d.get('bind_interface'),
7500            database=d.get('database'),
7501            egress_filter=d.get('egress_filter'),
7502            healthy=d.get('healthy'),
7503            hostname=d.get('hostname'),
7504            id=d.get('id'),
7505            name=d.get('name'),
7506            password=d.get('password'),
7507            port=d.get('port'),
7508            port_override=d.get('port_override'),
7509            secret_store_id=d.get('secret_store_id'),
7510            tags=d.get('tags'),
7511            username=d.get('username'),
7512        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7393    def __init__(
7394        self,
7395        bind_interface=None,
7396        database=None,
7397        egress_filter=None,
7398        healthy=None,
7399        hostname=None,
7400        id=None,
7401        name=None,
7402        password=None,
7403        port=None,
7404        port_override=None,
7405        secret_store_id=None,
7406        tags=None,
7407        username=None,
7408    ):
7409        self.bind_interface = bind_interface if bind_interface is not None else ''
7410        '''
7411         Bind interface
7412        '''
7413        self.database = database if database is not None else ''
7414        '''
7415
7416        '''
7417        self.egress_filter = egress_filter if egress_filter is not None else ''
7418        '''
7419         A filter applied to the routing logic to pin datasource to nodes.
7420        '''
7421        self.healthy = healthy if healthy is not None else False
7422        '''
7423         True if the datasource is reachable and the credentials are valid.
7424        '''
7425        self.hostname = hostname if hostname is not None else ''
7426        '''
7427
7428        '''
7429        self.id = id if id is not None else ''
7430        '''
7431         Unique identifier of the Resource.
7432        '''
7433        self.name = name if name is not None else ''
7434        '''
7435         Unique human-readable name of the Resource.
7436        '''
7437        self.password = password if password is not None else ''
7438        '''
7439
7440        '''
7441        self.port = port if port is not None else 0
7442        '''
7443
7444        '''
7445        self.port_override = port_override if port_override is not None else 0
7446        '''
7447
7448        '''
7449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7450        '''
7451         ID of the secret store containing credentials for this resource, if any.
7452        '''
7453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7454        '''
7455         Tags is a map of key, value pairs.
7456        '''
7457        self.username = username if username is not None else ''
7458        '''
7459
7460        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7479    def to_dict(self):
7480        return {
7481            'bind_interface': self.bind_interface,
7482            'database': self.database,
7483            'egress_filter': self.egress_filter,
7484            'healthy': self.healthy,
7485            'hostname': self.hostname,
7486            'id': self.id,
7487            'name': self.name,
7488            'password': self.password,
7489            'port': self.port,
7490            'port_override': self.port_override,
7491            'secret_store_id': self.secret_store_id,
7492            'tags': self.tags,
7493            'username': self.username,
7494        }
@classmethod
def from_dict(cls, d)
7496    @classmethod
7497    def from_dict(cls, d):
7498        return cls(
7499            bind_interface=d.get('bind_interface'),
7500            database=d.get('database'),
7501            egress_filter=d.get('egress_filter'),
7502            healthy=d.get('healthy'),
7503            hostname=d.get('hostname'),
7504            id=d.get('id'),
7505            name=d.get('name'),
7506            password=d.get('password'),
7507            port=d.get('port'),
7508            port_override=d.get('port_override'),
7509            secret_store_id=d.get('secret_store_id'),
7510            tags=d.get('tags'),
7511            username=d.get('username'),
7512        )
class Memcached:
7515class Memcached:
7516    '''
7517
7518    '''
7519    __slots__ = [
7520        'bind_interface',
7521        'egress_filter',
7522        'healthy',
7523        'hostname',
7524        'id',
7525        'name',
7526        'port',
7527        'port_override',
7528        'secret_store_id',
7529        'tags',
7530    ]
7531
7532    def __init__(
7533        self,
7534        bind_interface=None,
7535        egress_filter=None,
7536        healthy=None,
7537        hostname=None,
7538        id=None,
7539        name=None,
7540        port=None,
7541        port_override=None,
7542        secret_store_id=None,
7543        tags=None,
7544    ):
7545        self.bind_interface = bind_interface if bind_interface is not None else ''
7546        '''
7547         Bind interface
7548        '''
7549        self.egress_filter = egress_filter if egress_filter is not None else ''
7550        '''
7551         A filter applied to the routing logic to pin datasource to nodes.
7552        '''
7553        self.healthy = healthy if healthy is not None else False
7554        '''
7555         True if the datasource is reachable and the credentials are valid.
7556        '''
7557        self.hostname = hostname if hostname is not None else ''
7558        '''
7559
7560        '''
7561        self.id = id if id is not None else ''
7562        '''
7563         Unique identifier of the Resource.
7564        '''
7565        self.name = name if name is not None else ''
7566        '''
7567         Unique human-readable name of the Resource.
7568        '''
7569        self.port = port if port is not None else 0
7570        '''
7571
7572        '''
7573        self.port_override = port_override if port_override is not None else 0
7574        '''
7575
7576        '''
7577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7578        '''
7579         ID of the secret store containing credentials for this resource, if any.
7580        '''
7581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7582        '''
7583         Tags is a map of key, value pairs.
7584        '''
7585
7586    def __repr__(self):
7587        return '<sdm.Memcached ' + \
7588            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7589            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7590            'healthy: ' + repr(self.healthy) + ' ' +\
7591            'hostname: ' + repr(self.hostname) + ' ' +\
7592            'id: ' + repr(self.id) + ' ' +\
7593            'name: ' + repr(self.name) + ' ' +\
7594            'port: ' + repr(self.port) + ' ' +\
7595            'port_override: ' + repr(self.port_override) + ' ' +\
7596            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7597            'tags: ' + repr(self.tags) + ' ' +\
7598            '>'
7599
7600    def to_dict(self):
7601        return {
7602            'bind_interface': self.bind_interface,
7603            'egress_filter': self.egress_filter,
7604            'healthy': self.healthy,
7605            'hostname': self.hostname,
7606            'id': self.id,
7607            'name': self.name,
7608            'port': self.port,
7609            'port_override': self.port_override,
7610            'secret_store_id': self.secret_store_id,
7611            'tags': self.tags,
7612        }
7613
7614    @classmethod
7615    def from_dict(cls, d):
7616        return cls(
7617            bind_interface=d.get('bind_interface'),
7618            egress_filter=d.get('egress_filter'),
7619            healthy=d.get('healthy'),
7620            hostname=d.get('hostname'),
7621            id=d.get('id'),
7622            name=d.get('name'),
7623            port=d.get('port'),
7624            port_override=d.get('port_override'),
7625            secret_store_id=d.get('secret_store_id'),
7626            tags=d.get('tags'),
7627        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7532    def __init__(
7533        self,
7534        bind_interface=None,
7535        egress_filter=None,
7536        healthy=None,
7537        hostname=None,
7538        id=None,
7539        name=None,
7540        port=None,
7541        port_override=None,
7542        secret_store_id=None,
7543        tags=None,
7544    ):
7545        self.bind_interface = bind_interface if bind_interface is not None else ''
7546        '''
7547         Bind interface
7548        '''
7549        self.egress_filter = egress_filter if egress_filter is not None else ''
7550        '''
7551         A filter applied to the routing logic to pin datasource to nodes.
7552        '''
7553        self.healthy = healthy if healthy is not None else False
7554        '''
7555         True if the datasource is reachable and the credentials are valid.
7556        '''
7557        self.hostname = hostname if hostname is not None else ''
7558        '''
7559
7560        '''
7561        self.id = id if id is not None else ''
7562        '''
7563         Unique identifier of the Resource.
7564        '''
7565        self.name = name if name is not None else ''
7566        '''
7567         Unique human-readable name of the Resource.
7568        '''
7569        self.port = port if port is not None else 0
7570        '''
7571
7572        '''
7573        self.port_override = port_override if port_override is not None else 0
7574        '''
7575
7576        '''
7577        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7578        '''
7579         ID of the secret store containing credentials for this resource, if any.
7580        '''
7581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7582        '''
7583         Tags is a map of key, value pairs.
7584        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7600    def to_dict(self):
7601        return {
7602            'bind_interface': self.bind_interface,
7603            'egress_filter': self.egress_filter,
7604            'healthy': self.healthy,
7605            'hostname': self.hostname,
7606            'id': self.id,
7607            'name': self.name,
7608            'port': self.port,
7609            'port_override': self.port_override,
7610            'secret_store_id': self.secret_store_id,
7611            'tags': self.tags,
7612        }
@classmethod
def from_dict(cls, d)
7614    @classmethod
7615    def from_dict(cls, d):
7616        return cls(
7617            bind_interface=d.get('bind_interface'),
7618            egress_filter=d.get('egress_filter'),
7619            healthy=d.get('healthy'),
7620            hostname=d.get('hostname'),
7621            id=d.get('id'),
7622            name=d.get('name'),
7623            port=d.get('port'),
7624            port_override=d.get('port_override'),
7625            secret_store_id=d.get('secret_store_id'),
7626            tags=d.get('tags'),
7627        )
class Memsql:
7630class Memsql:
7631    '''
7632
7633    '''
7634    __slots__ = [
7635        'bind_interface',
7636        'database',
7637        'egress_filter',
7638        'healthy',
7639        'hostname',
7640        'id',
7641        'name',
7642        'password',
7643        'port',
7644        'port_override',
7645        'secret_store_id',
7646        'tags',
7647        'username',
7648    ]
7649
7650    def __init__(
7651        self,
7652        bind_interface=None,
7653        database=None,
7654        egress_filter=None,
7655        healthy=None,
7656        hostname=None,
7657        id=None,
7658        name=None,
7659        password=None,
7660        port=None,
7661        port_override=None,
7662        secret_store_id=None,
7663        tags=None,
7664        username=None,
7665    ):
7666        self.bind_interface = bind_interface if bind_interface is not None else ''
7667        '''
7668         Bind interface
7669        '''
7670        self.database = database if database is not None else ''
7671        '''
7672
7673        '''
7674        self.egress_filter = egress_filter if egress_filter is not None else ''
7675        '''
7676         A filter applied to the routing logic to pin datasource to nodes.
7677        '''
7678        self.healthy = healthy if healthy is not None else False
7679        '''
7680         True if the datasource is reachable and the credentials are valid.
7681        '''
7682        self.hostname = hostname if hostname is not None else ''
7683        '''
7684
7685        '''
7686        self.id = id if id is not None else ''
7687        '''
7688         Unique identifier of the Resource.
7689        '''
7690        self.name = name if name is not None else ''
7691        '''
7692         Unique human-readable name of the Resource.
7693        '''
7694        self.password = password if password is not None else ''
7695        '''
7696
7697        '''
7698        self.port = port if port is not None else 0
7699        '''
7700
7701        '''
7702        self.port_override = port_override if port_override is not None else 0
7703        '''
7704
7705        '''
7706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7707        '''
7708         ID of the secret store containing credentials for this resource, if any.
7709        '''
7710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7711        '''
7712         Tags is a map of key, value pairs.
7713        '''
7714        self.username = username if username is not None else ''
7715        '''
7716
7717        '''
7718
7719    def __repr__(self):
7720        return '<sdm.Memsql ' + \
7721            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7722            'database: ' + repr(self.database) + ' ' +\
7723            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7724            'healthy: ' + repr(self.healthy) + ' ' +\
7725            'hostname: ' + repr(self.hostname) + ' ' +\
7726            'id: ' + repr(self.id) + ' ' +\
7727            'name: ' + repr(self.name) + ' ' +\
7728            'password: ' + repr(self.password) + ' ' +\
7729            'port: ' + repr(self.port) + ' ' +\
7730            'port_override: ' + repr(self.port_override) + ' ' +\
7731            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7732            'tags: ' + repr(self.tags) + ' ' +\
7733            'username: ' + repr(self.username) + ' ' +\
7734            '>'
7735
7736    def to_dict(self):
7737        return {
7738            'bind_interface': self.bind_interface,
7739            'database': self.database,
7740            'egress_filter': self.egress_filter,
7741            'healthy': self.healthy,
7742            'hostname': self.hostname,
7743            'id': self.id,
7744            'name': self.name,
7745            'password': self.password,
7746            'port': self.port,
7747            'port_override': self.port_override,
7748            'secret_store_id': self.secret_store_id,
7749            'tags': self.tags,
7750            'username': self.username,
7751        }
7752
7753    @classmethod
7754    def from_dict(cls, d):
7755        return cls(
7756            bind_interface=d.get('bind_interface'),
7757            database=d.get('database'),
7758            egress_filter=d.get('egress_filter'),
7759            healthy=d.get('healthy'),
7760            hostname=d.get('hostname'),
7761            id=d.get('id'),
7762            name=d.get('name'),
7763            password=d.get('password'),
7764            port=d.get('port'),
7765            port_override=d.get('port_override'),
7766            secret_store_id=d.get('secret_store_id'),
7767            tags=d.get('tags'),
7768            username=d.get('username'),
7769        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7650    def __init__(
7651        self,
7652        bind_interface=None,
7653        database=None,
7654        egress_filter=None,
7655        healthy=None,
7656        hostname=None,
7657        id=None,
7658        name=None,
7659        password=None,
7660        port=None,
7661        port_override=None,
7662        secret_store_id=None,
7663        tags=None,
7664        username=None,
7665    ):
7666        self.bind_interface = bind_interface if bind_interface is not None else ''
7667        '''
7668         Bind interface
7669        '''
7670        self.database = database if database is not None else ''
7671        '''
7672
7673        '''
7674        self.egress_filter = egress_filter if egress_filter is not None else ''
7675        '''
7676         A filter applied to the routing logic to pin datasource to nodes.
7677        '''
7678        self.healthy = healthy if healthy is not None else False
7679        '''
7680         True if the datasource is reachable and the credentials are valid.
7681        '''
7682        self.hostname = hostname if hostname is not None else ''
7683        '''
7684
7685        '''
7686        self.id = id if id is not None else ''
7687        '''
7688         Unique identifier of the Resource.
7689        '''
7690        self.name = name if name is not None else ''
7691        '''
7692         Unique human-readable name of the Resource.
7693        '''
7694        self.password = password if password is not None else ''
7695        '''
7696
7697        '''
7698        self.port = port if port is not None else 0
7699        '''
7700
7701        '''
7702        self.port_override = port_override if port_override is not None else 0
7703        '''
7704
7705        '''
7706        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7707        '''
7708         ID of the secret store containing credentials for this resource, if any.
7709        '''
7710        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7711        '''
7712         Tags is a map of key, value pairs.
7713        '''
7714        self.username = username if username is not None else ''
7715        '''
7716
7717        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7736    def to_dict(self):
7737        return {
7738            'bind_interface': self.bind_interface,
7739            'database': self.database,
7740            'egress_filter': self.egress_filter,
7741            'healthy': self.healthy,
7742            'hostname': self.hostname,
7743            'id': self.id,
7744            'name': self.name,
7745            'password': self.password,
7746            'port': self.port,
7747            'port_override': self.port_override,
7748            'secret_store_id': self.secret_store_id,
7749            'tags': self.tags,
7750            'username': self.username,
7751        }
@classmethod
def from_dict(cls, d)
7753    @classmethod
7754    def from_dict(cls, d):
7755        return cls(
7756            bind_interface=d.get('bind_interface'),
7757            database=d.get('database'),
7758            egress_filter=d.get('egress_filter'),
7759            healthy=d.get('healthy'),
7760            hostname=d.get('hostname'),
7761            id=d.get('id'),
7762            name=d.get('name'),
7763            password=d.get('password'),
7764            port=d.get('port'),
7765            port_override=d.get('port_override'),
7766            secret_store_id=d.get('secret_store_id'),
7767            tags=d.get('tags'),
7768            username=d.get('username'),
7769        )
class MongoHost:
7772class MongoHost:
7773    '''
7774
7775    '''
7776    __slots__ = [
7777        'auth_database',
7778        'bind_interface',
7779        'egress_filter',
7780        'healthy',
7781        'hostname',
7782        'id',
7783        'name',
7784        'password',
7785        'port',
7786        'port_override',
7787        'secret_store_id',
7788        'tags',
7789        'tls_required',
7790        'username',
7791    ]
7792
7793    def __init__(
7794        self,
7795        auth_database=None,
7796        bind_interface=None,
7797        egress_filter=None,
7798        healthy=None,
7799        hostname=None,
7800        id=None,
7801        name=None,
7802        password=None,
7803        port=None,
7804        port_override=None,
7805        secret_store_id=None,
7806        tags=None,
7807        tls_required=None,
7808        username=None,
7809    ):
7810        self.auth_database = auth_database if auth_database is not None else ''
7811        '''
7812
7813        '''
7814        self.bind_interface = bind_interface if bind_interface is not None else ''
7815        '''
7816         Bind interface
7817        '''
7818        self.egress_filter = egress_filter if egress_filter is not None else ''
7819        '''
7820         A filter applied to the routing logic to pin datasource to nodes.
7821        '''
7822        self.healthy = healthy if healthy is not None else False
7823        '''
7824         True if the datasource is reachable and the credentials are valid.
7825        '''
7826        self.hostname = hostname if hostname is not None else ''
7827        '''
7828
7829        '''
7830        self.id = id if id is not None else ''
7831        '''
7832         Unique identifier of the Resource.
7833        '''
7834        self.name = name if name is not None else ''
7835        '''
7836         Unique human-readable name of the Resource.
7837        '''
7838        self.password = password if password is not None else ''
7839        '''
7840
7841        '''
7842        self.port = port if port is not None else 0
7843        '''
7844
7845        '''
7846        self.port_override = port_override if port_override is not None else 0
7847        '''
7848
7849        '''
7850        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7851        '''
7852         ID of the secret store containing credentials for this resource, if any.
7853        '''
7854        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7855        '''
7856         Tags is a map of key, value pairs.
7857        '''
7858        self.tls_required = tls_required if tls_required is not None else False
7859        '''
7860
7861        '''
7862        self.username = username if username is not None else ''
7863        '''
7864
7865        '''
7866
7867    def __repr__(self):
7868        return '<sdm.MongoHost ' + \
7869            'auth_database: ' + repr(self.auth_database) + ' ' +\
7870            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7872            'healthy: ' + repr(self.healthy) + ' ' +\
7873            'hostname: ' + repr(self.hostname) + ' ' +\
7874            'id: ' + repr(self.id) + ' ' +\
7875            'name: ' + repr(self.name) + ' ' +\
7876            'password: ' + repr(self.password) + ' ' +\
7877            'port: ' + repr(self.port) + ' ' +\
7878            'port_override: ' + repr(self.port_override) + ' ' +\
7879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7880            'tags: ' + repr(self.tags) + ' ' +\
7881            'tls_required: ' + repr(self.tls_required) + ' ' +\
7882            'username: ' + repr(self.username) + ' ' +\
7883            '>'
7884
7885    def to_dict(self):
7886        return {
7887            'auth_database': self.auth_database,
7888            'bind_interface': self.bind_interface,
7889            'egress_filter': self.egress_filter,
7890            'healthy': self.healthy,
7891            'hostname': self.hostname,
7892            'id': self.id,
7893            'name': self.name,
7894            'password': self.password,
7895            'port': self.port,
7896            'port_override': self.port_override,
7897            'secret_store_id': self.secret_store_id,
7898            'tags': self.tags,
7899            'tls_required': self.tls_required,
7900            'username': self.username,
7901        }
7902
7903    @classmethod
7904    def from_dict(cls, d):
7905        return cls(
7906            auth_database=d.get('auth_database'),
7907            bind_interface=d.get('bind_interface'),
7908            egress_filter=d.get('egress_filter'),
7909            healthy=d.get('healthy'),
7910            hostname=d.get('hostname'),
7911            id=d.get('id'),
7912            name=d.get('name'),
7913            password=d.get('password'),
7914            port=d.get('port'),
7915            port_override=d.get('port_override'),
7916            secret_store_id=d.get('secret_store_id'),
7917            tags=d.get('tags'),
7918            tls_required=d.get('tls_required'),
7919            username=d.get('username'),
7920        )
MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7793    def __init__(
7794        self,
7795        auth_database=None,
7796        bind_interface=None,
7797        egress_filter=None,
7798        healthy=None,
7799        hostname=None,
7800        id=None,
7801        name=None,
7802        password=None,
7803        port=None,
7804        port_override=None,
7805        secret_store_id=None,
7806        tags=None,
7807        tls_required=None,
7808        username=None,
7809    ):
7810        self.auth_database = auth_database if auth_database is not None else ''
7811        '''
7812
7813        '''
7814        self.bind_interface = bind_interface if bind_interface is not None else ''
7815        '''
7816         Bind interface
7817        '''
7818        self.egress_filter = egress_filter if egress_filter is not None else ''
7819        '''
7820         A filter applied to the routing logic to pin datasource to nodes.
7821        '''
7822        self.healthy = healthy if healthy is not None else False
7823        '''
7824         True if the datasource is reachable and the credentials are valid.
7825        '''
7826        self.hostname = hostname if hostname is not None else ''
7827        '''
7828
7829        '''
7830        self.id = id if id is not None else ''
7831        '''
7832         Unique identifier of the Resource.
7833        '''
7834        self.name = name if name is not None else ''
7835        '''
7836         Unique human-readable name of the Resource.
7837        '''
7838        self.password = password if password is not None else ''
7839        '''
7840
7841        '''
7842        self.port = port if port is not None else 0
7843        '''
7844
7845        '''
7846        self.port_override = port_override if port_override is not None else 0
7847        '''
7848
7849        '''
7850        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7851        '''
7852         ID of the secret store containing credentials for this resource, if any.
7853        '''
7854        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7855        '''
7856         Tags is a map of key, value pairs.
7857        '''
7858        self.tls_required = tls_required if tls_required is not None else False
7859        '''
7860
7861        '''
7862        self.username = username if username is not None else ''
7863        '''
7864
7865        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7885    def to_dict(self):
7886        return {
7887            'auth_database': self.auth_database,
7888            'bind_interface': self.bind_interface,
7889            'egress_filter': self.egress_filter,
7890            'healthy': self.healthy,
7891            'hostname': self.hostname,
7892            'id': self.id,
7893            'name': self.name,
7894            'password': self.password,
7895            'port': self.port,
7896            'port_override': self.port_override,
7897            'secret_store_id': self.secret_store_id,
7898            'tags': self.tags,
7899            'tls_required': self.tls_required,
7900            'username': self.username,
7901        }
@classmethod
def from_dict(cls, d)
7903    @classmethod
7904    def from_dict(cls, d):
7905        return cls(
7906            auth_database=d.get('auth_database'),
7907            bind_interface=d.get('bind_interface'),
7908            egress_filter=d.get('egress_filter'),
7909            healthy=d.get('healthy'),
7910            hostname=d.get('hostname'),
7911            id=d.get('id'),
7912            name=d.get('name'),
7913            password=d.get('password'),
7914            port=d.get('port'),
7915            port_override=d.get('port_override'),
7916            secret_store_id=d.get('secret_store_id'),
7917            tags=d.get('tags'),
7918            tls_required=d.get('tls_required'),
7919            username=d.get('username'),
7920        )
class MongoLegacyHost:
7923class MongoLegacyHost:
7924    '''
7925
7926    '''
7927    __slots__ = [
7928        'auth_database',
7929        'bind_interface',
7930        'egress_filter',
7931        'healthy',
7932        'hostname',
7933        'id',
7934        'name',
7935        'password',
7936        'port',
7937        'port_override',
7938        'replica_set',
7939        'secret_store_id',
7940        'tags',
7941        'tls_required',
7942        'username',
7943    ]
7944
7945    def __init__(
7946        self,
7947        auth_database=None,
7948        bind_interface=None,
7949        egress_filter=None,
7950        healthy=None,
7951        hostname=None,
7952        id=None,
7953        name=None,
7954        password=None,
7955        port=None,
7956        port_override=None,
7957        replica_set=None,
7958        secret_store_id=None,
7959        tags=None,
7960        tls_required=None,
7961        username=None,
7962    ):
7963        self.auth_database = auth_database if auth_database is not None else ''
7964        '''
7965
7966        '''
7967        self.bind_interface = bind_interface if bind_interface is not None else ''
7968        '''
7969         Bind interface
7970        '''
7971        self.egress_filter = egress_filter if egress_filter is not None else ''
7972        '''
7973         A filter applied to the routing logic to pin datasource to nodes.
7974        '''
7975        self.healthy = healthy if healthy is not None else False
7976        '''
7977         True if the datasource is reachable and the credentials are valid.
7978        '''
7979        self.hostname = hostname if hostname is not None else ''
7980        '''
7981
7982        '''
7983        self.id = id if id is not None else ''
7984        '''
7985         Unique identifier of the Resource.
7986        '''
7987        self.name = name if name is not None else ''
7988        '''
7989         Unique human-readable name of the Resource.
7990        '''
7991        self.password = password if password is not None else ''
7992        '''
7993
7994        '''
7995        self.port = port if port is not None else 0
7996        '''
7997
7998        '''
7999        self.port_override = port_override if port_override is not None else 0
8000        '''
8001
8002        '''
8003        self.replica_set = replica_set if replica_set is not None else ''
8004        '''
8005
8006        '''
8007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8008        '''
8009         ID of the secret store containing credentials for this resource, if any.
8010        '''
8011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8012        '''
8013         Tags is a map of key, value pairs.
8014        '''
8015        self.tls_required = tls_required if tls_required is not None else False
8016        '''
8017
8018        '''
8019        self.username = username if username is not None else ''
8020        '''
8021
8022        '''
8023
8024    def __repr__(self):
8025        return '<sdm.MongoLegacyHost ' + \
8026            'auth_database: ' + repr(self.auth_database) + ' ' +\
8027            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8028            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8029            'healthy: ' + repr(self.healthy) + ' ' +\
8030            'hostname: ' + repr(self.hostname) + ' ' +\
8031            'id: ' + repr(self.id) + ' ' +\
8032            'name: ' + repr(self.name) + ' ' +\
8033            'password: ' + repr(self.password) + ' ' +\
8034            'port: ' + repr(self.port) + ' ' +\
8035            'port_override: ' + repr(self.port_override) + ' ' +\
8036            'replica_set: ' + repr(self.replica_set) + ' ' +\
8037            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8038            'tags: ' + repr(self.tags) + ' ' +\
8039            'tls_required: ' + repr(self.tls_required) + ' ' +\
8040            'username: ' + repr(self.username) + ' ' +\
8041            '>'
8042
8043    def to_dict(self):
8044        return {
8045            'auth_database': self.auth_database,
8046            'bind_interface': self.bind_interface,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'replica_set': self.replica_set,
8056            'secret_store_id': self.secret_store_id,
8057            'tags': self.tags,
8058            'tls_required': self.tls_required,
8059            'username': self.username,
8060        }
8061
8062    @classmethod
8063    def from_dict(cls, d):
8064        return cls(
8065            auth_database=d.get('auth_database'),
8066            bind_interface=d.get('bind_interface'),
8067            egress_filter=d.get('egress_filter'),
8068            healthy=d.get('healthy'),
8069            hostname=d.get('hostname'),
8070            id=d.get('id'),
8071            name=d.get('name'),
8072            password=d.get('password'),
8073            port=d.get('port'),
8074            port_override=d.get('port_override'),
8075            replica_set=d.get('replica_set'),
8076            secret_store_id=d.get('secret_store_id'),
8077            tags=d.get('tags'),
8078            tls_required=d.get('tls_required'),
8079            username=d.get('username'),
8080        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7945    def __init__(
7946        self,
7947        auth_database=None,
7948        bind_interface=None,
7949        egress_filter=None,
7950        healthy=None,
7951        hostname=None,
7952        id=None,
7953        name=None,
7954        password=None,
7955        port=None,
7956        port_override=None,
7957        replica_set=None,
7958        secret_store_id=None,
7959        tags=None,
7960        tls_required=None,
7961        username=None,
7962    ):
7963        self.auth_database = auth_database if auth_database is not None else ''
7964        '''
7965
7966        '''
7967        self.bind_interface = bind_interface if bind_interface is not None else ''
7968        '''
7969         Bind interface
7970        '''
7971        self.egress_filter = egress_filter if egress_filter is not None else ''
7972        '''
7973         A filter applied to the routing logic to pin datasource to nodes.
7974        '''
7975        self.healthy = healthy if healthy is not None else False
7976        '''
7977         True if the datasource is reachable and the credentials are valid.
7978        '''
7979        self.hostname = hostname if hostname is not None else ''
7980        '''
7981
7982        '''
7983        self.id = id if id is not None else ''
7984        '''
7985         Unique identifier of the Resource.
7986        '''
7987        self.name = name if name is not None else ''
7988        '''
7989         Unique human-readable name of the Resource.
7990        '''
7991        self.password = password if password is not None else ''
7992        '''
7993
7994        '''
7995        self.port = port if port is not None else 0
7996        '''
7997
7998        '''
7999        self.port_override = port_override if port_override is not None else 0
8000        '''
8001
8002        '''
8003        self.replica_set = replica_set if replica_set is not None else ''
8004        '''
8005
8006        '''
8007        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8008        '''
8009         ID of the secret store containing credentials for this resource, if any.
8010        '''
8011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8012        '''
8013         Tags is a map of key, value pairs.
8014        '''
8015        self.tls_required = tls_required if tls_required is not None else False
8016        '''
8017
8018        '''
8019        self.username = username if username is not None else ''
8020        '''
8021
8022        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8043    def to_dict(self):
8044        return {
8045            'auth_database': self.auth_database,
8046            'bind_interface': self.bind_interface,
8047            'egress_filter': self.egress_filter,
8048            'healthy': self.healthy,
8049            'hostname': self.hostname,
8050            'id': self.id,
8051            'name': self.name,
8052            'password': self.password,
8053            'port': self.port,
8054            'port_override': self.port_override,
8055            'replica_set': self.replica_set,
8056            'secret_store_id': self.secret_store_id,
8057            'tags': self.tags,
8058            'tls_required': self.tls_required,
8059            'username': self.username,
8060        }
@classmethod
def from_dict(cls, d)
8062    @classmethod
8063    def from_dict(cls, d):
8064        return cls(
8065            auth_database=d.get('auth_database'),
8066            bind_interface=d.get('bind_interface'),
8067            egress_filter=d.get('egress_filter'),
8068            healthy=d.get('healthy'),
8069            hostname=d.get('hostname'),
8070            id=d.get('id'),
8071            name=d.get('name'),
8072            password=d.get('password'),
8073            port=d.get('port'),
8074            port_override=d.get('port_override'),
8075            replica_set=d.get('replica_set'),
8076            secret_store_id=d.get('secret_store_id'),
8077            tags=d.get('tags'),
8078            tls_required=d.get('tls_required'),
8079            username=d.get('username'),
8080        )
class MongoLegacyReplicaset:
8083class MongoLegacyReplicaset:
8084    '''
8085
8086    '''
8087    __slots__ = [
8088        'auth_database',
8089        'bind_interface',
8090        'connect_to_replica',
8091        'egress_filter',
8092        'healthy',
8093        'hostname',
8094        'id',
8095        'name',
8096        'password',
8097        'port',
8098        'port_override',
8099        'replica_set',
8100        'secret_store_id',
8101        'tags',
8102        'tls_required',
8103        'username',
8104    ]
8105
8106    def __init__(
8107        self,
8108        auth_database=None,
8109        bind_interface=None,
8110        connect_to_replica=None,
8111        egress_filter=None,
8112        healthy=None,
8113        hostname=None,
8114        id=None,
8115        name=None,
8116        password=None,
8117        port=None,
8118        port_override=None,
8119        replica_set=None,
8120        secret_store_id=None,
8121        tags=None,
8122        tls_required=None,
8123        username=None,
8124    ):
8125        self.auth_database = auth_database if auth_database is not None else ''
8126        '''
8127
8128        '''
8129        self.bind_interface = bind_interface if bind_interface is not None else ''
8130        '''
8131         Bind interface
8132        '''
8133        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8134        '''
8135
8136        '''
8137        self.egress_filter = egress_filter if egress_filter is not None else ''
8138        '''
8139         A filter applied to the routing logic to pin datasource to nodes.
8140        '''
8141        self.healthy = healthy if healthy is not None else False
8142        '''
8143         True if the datasource is reachable and the credentials are valid.
8144        '''
8145        self.hostname = hostname if hostname is not None else ''
8146        '''
8147
8148        '''
8149        self.id = id if id is not None else ''
8150        '''
8151         Unique identifier of the Resource.
8152        '''
8153        self.name = name if name is not None else ''
8154        '''
8155         Unique human-readable name of the Resource.
8156        '''
8157        self.password = password if password is not None else ''
8158        '''
8159
8160        '''
8161        self.port = port if port is not None else 0
8162        '''
8163
8164        '''
8165        self.port_override = port_override if port_override is not None else 0
8166        '''
8167
8168        '''
8169        self.replica_set = replica_set if replica_set is not None else ''
8170        '''
8171
8172        '''
8173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8174        '''
8175         ID of the secret store containing credentials for this resource, if any.
8176        '''
8177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8178        '''
8179         Tags is a map of key, value pairs.
8180        '''
8181        self.tls_required = tls_required if tls_required is not None else False
8182        '''
8183
8184        '''
8185        self.username = username if username is not None else ''
8186        '''
8187
8188        '''
8189
8190    def __repr__(self):
8191        return '<sdm.MongoLegacyReplicaset ' + \
8192            'auth_database: ' + repr(self.auth_database) + ' ' +\
8193            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8194            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8195            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8196            'healthy: ' + repr(self.healthy) + ' ' +\
8197            'hostname: ' + repr(self.hostname) + ' ' +\
8198            'id: ' + repr(self.id) + ' ' +\
8199            'name: ' + repr(self.name) + ' ' +\
8200            'password: ' + repr(self.password) + ' ' +\
8201            'port: ' + repr(self.port) + ' ' +\
8202            'port_override: ' + repr(self.port_override) + ' ' +\
8203            'replica_set: ' + repr(self.replica_set) + ' ' +\
8204            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8205            'tags: ' + repr(self.tags) + ' ' +\
8206            'tls_required: ' + repr(self.tls_required) + ' ' +\
8207            'username: ' + repr(self.username) + ' ' +\
8208            '>'
8209
8210    def to_dict(self):
8211        return {
8212            'auth_database': self.auth_database,
8213            'bind_interface': self.bind_interface,
8214            'connect_to_replica': self.connect_to_replica,
8215            'egress_filter': self.egress_filter,
8216            'healthy': self.healthy,
8217            'hostname': self.hostname,
8218            'id': self.id,
8219            'name': self.name,
8220            'password': self.password,
8221            'port': self.port,
8222            'port_override': self.port_override,
8223            'replica_set': self.replica_set,
8224            'secret_store_id': self.secret_store_id,
8225            'tags': self.tags,
8226            'tls_required': self.tls_required,
8227            'username': self.username,
8228        }
8229
8230    @classmethod
8231    def from_dict(cls, d):
8232        return cls(
8233            auth_database=d.get('auth_database'),
8234            bind_interface=d.get('bind_interface'),
8235            connect_to_replica=d.get('connect_to_replica'),
8236            egress_filter=d.get('egress_filter'),
8237            healthy=d.get('healthy'),
8238            hostname=d.get('hostname'),
8239            id=d.get('id'),
8240            name=d.get('name'),
8241            password=d.get('password'),
8242            port=d.get('port'),
8243            port_override=d.get('port_override'),
8244            replica_set=d.get('replica_set'),
8245            secret_store_id=d.get('secret_store_id'),
8246            tags=d.get('tags'),
8247            tls_required=d.get('tls_required'),
8248            username=d.get('username'),
8249        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8106    def __init__(
8107        self,
8108        auth_database=None,
8109        bind_interface=None,
8110        connect_to_replica=None,
8111        egress_filter=None,
8112        healthy=None,
8113        hostname=None,
8114        id=None,
8115        name=None,
8116        password=None,
8117        port=None,
8118        port_override=None,
8119        replica_set=None,
8120        secret_store_id=None,
8121        tags=None,
8122        tls_required=None,
8123        username=None,
8124    ):
8125        self.auth_database = auth_database if auth_database is not None else ''
8126        '''
8127
8128        '''
8129        self.bind_interface = bind_interface if bind_interface is not None else ''
8130        '''
8131         Bind interface
8132        '''
8133        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8134        '''
8135
8136        '''
8137        self.egress_filter = egress_filter if egress_filter is not None else ''
8138        '''
8139         A filter applied to the routing logic to pin datasource to nodes.
8140        '''
8141        self.healthy = healthy if healthy is not None else False
8142        '''
8143         True if the datasource is reachable and the credentials are valid.
8144        '''
8145        self.hostname = hostname if hostname is not None else ''
8146        '''
8147
8148        '''
8149        self.id = id if id is not None else ''
8150        '''
8151         Unique identifier of the Resource.
8152        '''
8153        self.name = name if name is not None else ''
8154        '''
8155         Unique human-readable name of the Resource.
8156        '''
8157        self.password = password if password is not None else ''
8158        '''
8159
8160        '''
8161        self.port = port if port is not None else 0
8162        '''
8163
8164        '''
8165        self.port_override = port_override if port_override is not None else 0
8166        '''
8167
8168        '''
8169        self.replica_set = replica_set if replica_set is not None else ''
8170        '''
8171
8172        '''
8173        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8174        '''
8175         ID of the secret store containing credentials for this resource, if any.
8176        '''
8177        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8178        '''
8179         Tags is a map of key, value pairs.
8180        '''
8181        self.tls_required = tls_required if tls_required is not None else False
8182        '''
8183
8184        '''
8185        self.username = username if username is not None else ''
8186        '''
8187
8188        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8210    def to_dict(self):
8211        return {
8212            'auth_database': self.auth_database,
8213            'bind_interface': self.bind_interface,
8214            'connect_to_replica': self.connect_to_replica,
8215            'egress_filter': self.egress_filter,
8216            'healthy': self.healthy,
8217            'hostname': self.hostname,
8218            'id': self.id,
8219            'name': self.name,
8220            'password': self.password,
8221            'port': self.port,
8222            'port_override': self.port_override,
8223            'replica_set': self.replica_set,
8224            'secret_store_id': self.secret_store_id,
8225            'tags': self.tags,
8226            'tls_required': self.tls_required,
8227            'username': self.username,
8228        }
@classmethod
def from_dict(cls, d)
8230    @classmethod
8231    def from_dict(cls, d):
8232        return cls(
8233            auth_database=d.get('auth_database'),
8234            bind_interface=d.get('bind_interface'),
8235            connect_to_replica=d.get('connect_to_replica'),
8236            egress_filter=d.get('egress_filter'),
8237            healthy=d.get('healthy'),
8238            hostname=d.get('hostname'),
8239            id=d.get('id'),
8240            name=d.get('name'),
8241            password=d.get('password'),
8242            port=d.get('port'),
8243            port_override=d.get('port_override'),
8244            replica_set=d.get('replica_set'),
8245            secret_store_id=d.get('secret_store_id'),
8246            tags=d.get('tags'),
8247            tls_required=d.get('tls_required'),
8248            username=d.get('username'),
8249        )
class MongoReplicaSet:
8252class MongoReplicaSet:
8253    '''
8254
8255    '''
8256    __slots__ = [
8257        'auth_database',
8258        'bind_interface',
8259        'connect_to_replica',
8260        'egress_filter',
8261        'healthy',
8262        'hostname',
8263        'id',
8264        'name',
8265        'password',
8266        'port',
8267        'port_override',
8268        'replica_set',
8269        'secret_store_id',
8270        'tags',
8271        'tls_required',
8272        'username',
8273    ]
8274
8275    def __init__(
8276        self,
8277        auth_database=None,
8278        bind_interface=None,
8279        connect_to_replica=None,
8280        egress_filter=None,
8281        healthy=None,
8282        hostname=None,
8283        id=None,
8284        name=None,
8285        password=None,
8286        port=None,
8287        port_override=None,
8288        replica_set=None,
8289        secret_store_id=None,
8290        tags=None,
8291        tls_required=None,
8292        username=None,
8293    ):
8294        self.auth_database = auth_database if auth_database is not None else ''
8295        '''
8296
8297        '''
8298        self.bind_interface = bind_interface if bind_interface is not None else ''
8299        '''
8300         Bind interface
8301        '''
8302        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8303        '''
8304
8305        '''
8306        self.egress_filter = egress_filter if egress_filter is not None else ''
8307        '''
8308         A filter applied to the routing logic to pin datasource to nodes.
8309        '''
8310        self.healthy = healthy if healthy is not None else False
8311        '''
8312         True if the datasource is reachable and the credentials are valid.
8313        '''
8314        self.hostname = hostname if hostname is not None else ''
8315        '''
8316
8317        '''
8318        self.id = id if id is not None else ''
8319        '''
8320         Unique identifier of the Resource.
8321        '''
8322        self.name = name if name is not None else ''
8323        '''
8324         Unique human-readable name of the Resource.
8325        '''
8326        self.password = password if password is not None else ''
8327        '''
8328
8329        '''
8330        self.port = port if port is not None else 0
8331        '''
8332
8333        '''
8334        self.port_override = port_override if port_override is not None else 0
8335        '''
8336
8337        '''
8338        self.replica_set = replica_set if replica_set is not None else ''
8339        '''
8340
8341        '''
8342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8343        '''
8344         ID of the secret store containing credentials for this resource, if any.
8345        '''
8346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8347        '''
8348         Tags is a map of key, value pairs.
8349        '''
8350        self.tls_required = tls_required if tls_required is not None else False
8351        '''
8352
8353        '''
8354        self.username = username if username is not None else ''
8355        '''
8356
8357        '''
8358
8359    def __repr__(self):
8360        return '<sdm.MongoReplicaSet ' + \
8361            'auth_database: ' + repr(self.auth_database) + ' ' +\
8362            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8363            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8364            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8365            'healthy: ' + repr(self.healthy) + ' ' +\
8366            'hostname: ' + repr(self.hostname) + ' ' +\
8367            'id: ' + repr(self.id) + ' ' +\
8368            'name: ' + repr(self.name) + ' ' +\
8369            'password: ' + repr(self.password) + ' ' +\
8370            'port: ' + repr(self.port) + ' ' +\
8371            'port_override: ' + repr(self.port_override) + ' ' +\
8372            'replica_set: ' + repr(self.replica_set) + ' ' +\
8373            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8374            'tags: ' + repr(self.tags) + ' ' +\
8375            'tls_required: ' + repr(self.tls_required) + ' ' +\
8376            'username: ' + repr(self.username) + ' ' +\
8377            '>'
8378
8379    def to_dict(self):
8380        return {
8381            'auth_database': self.auth_database,
8382            'bind_interface': self.bind_interface,
8383            'connect_to_replica': self.connect_to_replica,
8384            'egress_filter': self.egress_filter,
8385            'healthy': self.healthy,
8386            'hostname': self.hostname,
8387            'id': self.id,
8388            'name': self.name,
8389            'password': self.password,
8390            'port': self.port,
8391            'port_override': self.port_override,
8392            'replica_set': self.replica_set,
8393            'secret_store_id': self.secret_store_id,
8394            'tags': self.tags,
8395            'tls_required': self.tls_required,
8396            'username': self.username,
8397        }
8398
8399    @classmethod
8400    def from_dict(cls, d):
8401        return cls(
8402            auth_database=d.get('auth_database'),
8403            bind_interface=d.get('bind_interface'),
8404            connect_to_replica=d.get('connect_to_replica'),
8405            egress_filter=d.get('egress_filter'),
8406            healthy=d.get('healthy'),
8407            hostname=d.get('hostname'),
8408            id=d.get('id'),
8409            name=d.get('name'),
8410            password=d.get('password'),
8411            port=d.get('port'),
8412            port_override=d.get('port_override'),
8413            replica_set=d.get('replica_set'),
8414            secret_store_id=d.get('secret_store_id'),
8415            tags=d.get('tags'),
8416            tls_required=d.get('tls_required'),
8417            username=d.get('username'),
8418        )
MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8275    def __init__(
8276        self,
8277        auth_database=None,
8278        bind_interface=None,
8279        connect_to_replica=None,
8280        egress_filter=None,
8281        healthy=None,
8282        hostname=None,
8283        id=None,
8284        name=None,
8285        password=None,
8286        port=None,
8287        port_override=None,
8288        replica_set=None,
8289        secret_store_id=None,
8290        tags=None,
8291        tls_required=None,
8292        username=None,
8293    ):
8294        self.auth_database = auth_database if auth_database is not None else ''
8295        '''
8296
8297        '''
8298        self.bind_interface = bind_interface if bind_interface is not None else ''
8299        '''
8300         Bind interface
8301        '''
8302        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8303        '''
8304
8305        '''
8306        self.egress_filter = egress_filter if egress_filter is not None else ''
8307        '''
8308         A filter applied to the routing logic to pin datasource to nodes.
8309        '''
8310        self.healthy = healthy if healthy is not None else False
8311        '''
8312         True if the datasource is reachable and the credentials are valid.
8313        '''
8314        self.hostname = hostname if hostname is not None else ''
8315        '''
8316
8317        '''
8318        self.id = id if id is not None else ''
8319        '''
8320         Unique identifier of the Resource.
8321        '''
8322        self.name = name if name is not None else ''
8323        '''
8324         Unique human-readable name of the Resource.
8325        '''
8326        self.password = password if password is not None else ''
8327        '''
8328
8329        '''
8330        self.port = port if port is not None else 0
8331        '''
8332
8333        '''
8334        self.port_override = port_override if port_override is not None else 0
8335        '''
8336
8337        '''
8338        self.replica_set = replica_set if replica_set is not None else ''
8339        '''
8340
8341        '''
8342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8343        '''
8344         ID of the secret store containing credentials for this resource, if any.
8345        '''
8346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8347        '''
8348         Tags is a map of key, value pairs.
8349        '''
8350        self.tls_required = tls_required if tls_required is not None else False
8351        '''
8352
8353        '''
8354        self.username = username if username is not None else ''
8355        '''
8356
8357        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8379    def to_dict(self):
8380        return {
8381            'auth_database': self.auth_database,
8382            'bind_interface': self.bind_interface,
8383            'connect_to_replica': self.connect_to_replica,
8384            'egress_filter': self.egress_filter,
8385            'healthy': self.healthy,
8386            'hostname': self.hostname,
8387            'id': self.id,
8388            'name': self.name,
8389            'password': self.password,
8390            'port': self.port,
8391            'port_override': self.port_override,
8392            'replica_set': self.replica_set,
8393            'secret_store_id': self.secret_store_id,
8394            'tags': self.tags,
8395            'tls_required': self.tls_required,
8396            'username': self.username,
8397        }
@classmethod
def from_dict(cls, d)
8399    @classmethod
8400    def from_dict(cls, d):
8401        return cls(
8402            auth_database=d.get('auth_database'),
8403            bind_interface=d.get('bind_interface'),
8404            connect_to_replica=d.get('connect_to_replica'),
8405            egress_filter=d.get('egress_filter'),
8406            healthy=d.get('healthy'),
8407            hostname=d.get('hostname'),
8408            id=d.get('id'),
8409            name=d.get('name'),
8410            password=d.get('password'),
8411            port=d.get('port'),
8412            port_override=d.get('port_override'),
8413            replica_set=d.get('replica_set'),
8414            secret_store_id=d.get('secret_store_id'),
8415            tags=d.get('tags'),
8416            tls_required=d.get('tls_required'),
8417            username=d.get('username'),
8418        )
class MongoShardedCluster:
8421class MongoShardedCluster:
8422    '''
8423
8424    '''
8425    __slots__ = [
8426        'auth_database',
8427        'bind_interface',
8428        'egress_filter',
8429        'healthy',
8430        'hostname',
8431        'id',
8432        'name',
8433        'password',
8434        'port_override',
8435        'secret_store_id',
8436        'tags',
8437        'tls_required',
8438        'username',
8439    ]
8440
8441    def __init__(
8442        self,
8443        auth_database=None,
8444        bind_interface=None,
8445        egress_filter=None,
8446        healthy=None,
8447        hostname=None,
8448        id=None,
8449        name=None,
8450        password=None,
8451        port_override=None,
8452        secret_store_id=None,
8453        tags=None,
8454        tls_required=None,
8455        username=None,
8456    ):
8457        self.auth_database = auth_database if auth_database is not None else ''
8458        '''
8459
8460        '''
8461        self.bind_interface = bind_interface if bind_interface is not None else ''
8462        '''
8463         Bind interface
8464        '''
8465        self.egress_filter = egress_filter if egress_filter is not None else ''
8466        '''
8467         A filter applied to the routing logic to pin datasource to nodes.
8468        '''
8469        self.healthy = healthy if healthy is not None else False
8470        '''
8471         True if the datasource is reachable and the credentials are valid.
8472        '''
8473        self.hostname = hostname if hostname is not None else ''
8474        '''
8475
8476        '''
8477        self.id = id if id is not None else ''
8478        '''
8479         Unique identifier of the Resource.
8480        '''
8481        self.name = name if name is not None else ''
8482        '''
8483         Unique human-readable name of the Resource.
8484        '''
8485        self.password = password if password is not None else ''
8486        '''
8487
8488        '''
8489        self.port_override = port_override if port_override is not None else 0
8490        '''
8491
8492        '''
8493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8494        '''
8495         ID of the secret store containing credentials for this resource, if any.
8496        '''
8497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8498        '''
8499         Tags is a map of key, value pairs.
8500        '''
8501        self.tls_required = tls_required if tls_required is not None else False
8502        '''
8503
8504        '''
8505        self.username = username if username is not None else ''
8506        '''
8507
8508        '''
8509
8510    def __repr__(self):
8511        return '<sdm.MongoShardedCluster ' + \
8512            'auth_database: ' + repr(self.auth_database) + ' ' +\
8513            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8514            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8515            'healthy: ' + repr(self.healthy) + ' ' +\
8516            'hostname: ' + repr(self.hostname) + ' ' +\
8517            'id: ' + repr(self.id) + ' ' +\
8518            'name: ' + repr(self.name) + ' ' +\
8519            'password: ' + repr(self.password) + ' ' +\
8520            'port_override: ' + repr(self.port_override) + ' ' +\
8521            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8522            'tags: ' + repr(self.tags) + ' ' +\
8523            'tls_required: ' + repr(self.tls_required) + ' ' +\
8524            'username: ' + repr(self.username) + ' ' +\
8525            '>'
8526
8527    def to_dict(self):
8528        return {
8529            'auth_database': self.auth_database,
8530            'bind_interface': self.bind_interface,
8531            'egress_filter': self.egress_filter,
8532            'healthy': self.healthy,
8533            'hostname': self.hostname,
8534            'id': self.id,
8535            'name': self.name,
8536            'password': self.password,
8537            'port_override': self.port_override,
8538            'secret_store_id': self.secret_store_id,
8539            'tags': self.tags,
8540            'tls_required': self.tls_required,
8541            'username': self.username,
8542        }
8543
8544    @classmethod
8545    def from_dict(cls, d):
8546        return cls(
8547            auth_database=d.get('auth_database'),
8548            bind_interface=d.get('bind_interface'),
8549            egress_filter=d.get('egress_filter'),
8550            healthy=d.get('healthy'),
8551            hostname=d.get('hostname'),
8552            id=d.get('id'),
8553            name=d.get('name'),
8554            password=d.get('password'),
8555            port_override=d.get('port_override'),
8556            secret_store_id=d.get('secret_store_id'),
8557            tags=d.get('tags'),
8558            tls_required=d.get('tls_required'),
8559            username=d.get('username'),
8560        )
MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8441    def __init__(
8442        self,
8443        auth_database=None,
8444        bind_interface=None,
8445        egress_filter=None,
8446        healthy=None,
8447        hostname=None,
8448        id=None,
8449        name=None,
8450        password=None,
8451        port_override=None,
8452        secret_store_id=None,
8453        tags=None,
8454        tls_required=None,
8455        username=None,
8456    ):
8457        self.auth_database = auth_database if auth_database is not None else ''
8458        '''
8459
8460        '''
8461        self.bind_interface = bind_interface if bind_interface is not None else ''
8462        '''
8463         Bind interface
8464        '''
8465        self.egress_filter = egress_filter if egress_filter is not None else ''
8466        '''
8467         A filter applied to the routing logic to pin datasource to nodes.
8468        '''
8469        self.healthy = healthy if healthy is not None else False
8470        '''
8471         True if the datasource is reachable and the credentials are valid.
8472        '''
8473        self.hostname = hostname if hostname is not None else ''
8474        '''
8475
8476        '''
8477        self.id = id if id is not None else ''
8478        '''
8479         Unique identifier of the Resource.
8480        '''
8481        self.name = name if name is not None else ''
8482        '''
8483         Unique human-readable name of the Resource.
8484        '''
8485        self.password = password if password is not None else ''
8486        '''
8487
8488        '''
8489        self.port_override = port_override if port_override is not None else 0
8490        '''
8491
8492        '''
8493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8494        '''
8495         ID of the secret store containing credentials for this resource, if any.
8496        '''
8497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8498        '''
8499         Tags is a map of key, value pairs.
8500        '''
8501        self.tls_required = tls_required if tls_required is not None else False
8502        '''
8503
8504        '''
8505        self.username = username if username is not None else ''
8506        '''
8507
8508        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8527    def to_dict(self):
8528        return {
8529            'auth_database': self.auth_database,
8530            'bind_interface': self.bind_interface,
8531            'egress_filter': self.egress_filter,
8532            'healthy': self.healthy,
8533            'hostname': self.hostname,
8534            'id': self.id,
8535            'name': self.name,
8536            'password': self.password,
8537            'port_override': self.port_override,
8538            'secret_store_id': self.secret_store_id,
8539            'tags': self.tags,
8540            'tls_required': self.tls_required,
8541            'username': self.username,
8542        }
@classmethod
def from_dict(cls, d)
8544    @classmethod
8545    def from_dict(cls, d):
8546        return cls(
8547            auth_database=d.get('auth_database'),
8548            bind_interface=d.get('bind_interface'),
8549            egress_filter=d.get('egress_filter'),
8550            healthy=d.get('healthy'),
8551            hostname=d.get('hostname'),
8552            id=d.get('id'),
8553            name=d.get('name'),
8554            password=d.get('password'),
8555            port_override=d.get('port_override'),
8556            secret_store_id=d.get('secret_store_id'),
8557            tags=d.get('tags'),
8558            tls_required=d.get('tls_required'),
8559            username=d.get('username'),
8560        )
class Mysql:
8563class Mysql:
8564    '''
8565
8566    '''
8567    __slots__ = [
8568        'bind_interface',
8569        'database',
8570        'egress_filter',
8571        'healthy',
8572        'hostname',
8573        'id',
8574        'name',
8575        'password',
8576        'port',
8577        'port_override',
8578        'secret_store_id',
8579        'tags',
8580        'username',
8581    ]
8582
8583    def __init__(
8584        self,
8585        bind_interface=None,
8586        database=None,
8587        egress_filter=None,
8588        healthy=None,
8589        hostname=None,
8590        id=None,
8591        name=None,
8592        password=None,
8593        port=None,
8594        port_override=None,
8595        secret_store_id=None,
8596        tags=None,
8597        username=None,
8598    ):
8599        self.bind_interface = bind_interface if bind_interface is not None else ''
8600        '''
8601         Bind interface
8602        '''
8603        self.database = database if database is not None else ''
8604        '''
8605
8606        '''
8607        self.egress_filter = egress_filter if egress_filter is not None else ''
8608        '''
8609         A filter applied to the routing logic to pin datasource to nodes.
8610        '''
8611        self.healthy = healthy if healthy is not None else False
8612        '''
8613         True if the datasource is reachable and the credentials are valid.
8614        '''
8615        self.hostname = hostname if hostname is not None else ''
8616        '''
8617
8618        '''
8619        self.id = id if id is not None else ''
8620        '''
8621         Unique identifier of the Resource.
8622        '''
8623        self.name = name if name is not None else ''
8624        '''
8625         Unique human-readable name of the Resource.
8626        '''
8627        self.password = password if password is not None else ''
8628        '''
8629
8630        '''
8631        self.port = port if port is not None else 0
8632        '''
8633
8634        '''
8635        self.port_override = port_override if port_override is not None else 0
8636        '''
8637
8638        '''
8639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8640        '''
8641         ID of the secret store containing credentials for this resource, if any.
8642        '''
8643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8644        '''
8645         Tags is a map of key, value pairs.
8646        '''
8647        self.username = username if username is not None else ''
8648        '''
8649
8650        '''
8651
8652    def __repr__(self):
8653        return '<sdm.Mysql ' + \
8654            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8655            'database: ' + repr(self.database) + ' ' +\
8656            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8657            'healthy: ' + repr(self.healthy) + ' ' +\
8658            'hostname: ' + repr(self.hostname) + ' ' +\
8659            'id: ' + repr(self.id) + ' ' +\
8660            'name: ' + repr(self.name) + ' ' +\
8661            'password: ' + repr(self.password) + ' ' +\
8662            'port: ' + repr(self.port) + ' ' +\
8663            'port_override: ' + repr(self.port_override) + ' ' +\
8664            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8665            'tags: ' + repr(self.tags) + ' ' +\
8666            'username: ' + repr(self.username) + ' ' +\
8667            '>'
8668
8669    def to_dict(self):
8670        return {
8671            'bind_interface': self.bind_interface,
8672            'database': self.database,
8673            'egress_filter': self.egress_filter,
8674            'healthy': self.healthy,
8675            'hostname': self.hostname,
8676            'id': self.id,
8677            'name': self.name,
8678            'password': self.password,
8679            'port': self.port,
8680            'port_override': self.port_override,
8681            'secret_store_id': self.secret_store_id,
8682            'tags': self.tags,
8683            'username': self.username,
8684        }
8685
8686    @classmethod
8687    def from_dict(cls, d):
8688        return cls(
8689            bind_interface=d.get('bind_interface'),
8690            database=d.get('database'),
8691            egress_filter=d.get('egress_filter'),
8692            healthy=d.get('healthy'),
8693            hostname=d.get('hostname'),
8694            id=d.get('id'),
8695            name=d.get('name'),
8696            password=d.get('password'),
8697            port=d.get('port'),
8698            port_override=d.get('port_override'),
8699            secret_store_id=d.get('secret_store_id'),
8700            tags=d.get('tags'),
8701            username=d.get('username'),
8702        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8583    def __init__(
8584        self,
8585        bind_interface=None,
8586        database=None,
8587        egress_filter=None,
8588        healthy=None,
8589        hostname=None,
8590        id=None,
8591        name=None,
8592        password=None,
8593        port=None,
8594        port_override=None,
8595        secret_store_id=None,
8596        tags=None,
8597        username=None,
8598    ):
8599        self.bind_interface = bind_interface if bind_interface is not None else ''
8600        '''
8601         Bind interface
8602        '''
8603        self.database = database if database is not None else ''
8604        '''
8605
8606        '''
8607        self.egress_filter = egress_filter if egress_filter is not None else ''
8608        '''
8609         A filter applied to the routing logic to pin datasource to nodes.
8610        '''
8611        self.healthy = healthy if healthy is not None else False
8612        '''
8613         True if the datasource is reachable and the credentials are valid.
8614        '''
8615        self.hostname = hostname if hostname is not None else ''
8616        '''
8617
8618        '''
8619        self.id = id if id is not None else ''
8620        '''
8621         Unique identifier of the Resource.
8622        '''
8623        self.name = name if name is not None else ''
8624        '''
8625         Unique human-readable name of the Resource.
8626        '''
8627        self.password = password if password is not None else ''
8628        '''
8629
8630        '''
8631        self.port = port if port is not None else 0
8632        '''
8633
8634        '''
8635        self.port_override = port_override if port_override is not None else 0
8636        '''
8637
8638        '''
8639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8640        '''
8641         ID of the secret store containing credentials for this resource, if any.
8642        '''
8643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8644        '''
8645         Tags is a map of key, value pairs.
8646        '''
8647        self.username = username if username is not None else ''
8648        '''
8649
8650        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8669    def to_dict(self):
8670        return {
8671            'bind_interface': self.bind_interface,
8672            'database': self.database,
8673            'egress_filter': self.egress_filter,
8674            'healthy': self.healthy,
8675            'hostname': self.hostname,
8676            'id': self.id,
8677            'name': self.name,
8678            'password': self.password,
8679            'port': self.port,
8680            'port_override': self.port_override,
8681            'secret_store_id': self.secret_store_id,
8682            'tags': self.tags,
8683            'username': self.username,
8684        }
@classmethod
def from_dict(cls, d)
8686    @classmethod
8687    def from_dict(cls, d):
8688        return cls(
8689            bind_interface=d.get('bind_interface'),
8690            database=d.get('database'),
8691            egress_filter=d.get('egress_filter'),
8692            healthy=d.get('healthy'),
8693            hostname=d.get('hostname'),
8694            id=d.get('id'),
8695            name=d.get('name'),
8696            password=d.get('password'),
8697            port=d.get('port'),
8698            port_override=d.get('port_override'),
8699            secret_store_id=d.get('secret_store_id'),
8700            tags=d.get('tags'),
8701            username=d.get('username'),
8702        )
class Neptune:
8705class Neptune:
8706    '''
8707
8708    '''
8709    __slots__ = [
8710        'bind_interface',
8711        'egress_filter',
8712        'endpoint',
8713        'healthy',
8714        'id',
8715        'name',
8716        'port',
8717        'port_override',
8718        'secret_store_id',
8719        'tags',
8720    ]
8721
8722    def __init__(
8723        self,
8724        bind_interface=None,
8725        egress_filter=None,
8726        endpoint=None,
8727        healthy=None,
8728        id=None,
8729        name=None,
8730        port=None,
8731        port_override=None,
8732        secret_store_id=None,
8733        tags=None,
8734    ):
8735        self.bind_interface = bind_interface if bind_interface is not None else ''
8736        '''
8737         Bind interface
8738        '''
8739        self.egress_filter = egress_filter if egress_filter is not None else ''
8740        '''
8741         A filter applied to the routing logic to pin datasource to nodes.
8742        '''
8743        self.endpoint = endpoint if endpoint is not None else ''
8744        '''
8745
8746        '''
8747        self.healthy = healthy if healthy is not None else False
8748        '''
8749         True if the datasource is reachable and the credentials are valid.
8750        '''
8751        self.id = id if id is not None else ''
8752        '''
8753         Unique identifier of the Resource.
8754        '''
8755        self.name = name if name is not None else ''
8756        '''
8757         Unique human-readable name of the Resource.
8758        '''
8759        self.port = port if port is not None else 0
8760        '''
8761
8762        '''
8763        self.port_override = port_override if port_override is not None else 0
8764        '''
8765
8766        '''
8767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8768        '''
8769         ID of the secret store containing credentials for this resource, if any.
8770        '''
8771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8772        '''
8773         Tags is a map of key, value pairs.
8774        '''
8775
8776    def __repr__(self):
8777        return '<sdm.Neptune ' + \
8778            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8779            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8780            'endpoint: ' + repr(self.endpoint) + ' ' +\
8781            'healthy: ' + repr(self.healthy) + ' ' +\
8782            'id: ' + repr(self.id) + ' ' +\
8783            'name: ' + repr(self.name) + ' ' +\
8784            'port: ' + repr(self.port) + ' ' +\
8785            'port_override: ' + repr(self.port_override) + ' ' +\
8786            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8787            'tags: ' + repr(self.tags) + ' ' +\
8788            '>'
8789
8790    def to_dict(self):
8791        return {
8792            'bind_interface': self.bind_interface,
8793            'egress_filter': self.egress_filter,
8794            'endpoint': self.endpoint,
8795            'healthy': self.healthy,
8796            'id': self.id,
8797            'name': self.name,
8798            'port': self.port,
8799            'port_override': self.port_override,
8800            'secret_store_id': self.secret_store_id,
8801            'tags': self.tags,
8802        }
8803
8804    @classmethod
8805    def from_dict(cls, d):
8806        return cls(
8807            bind_interface=d.get('bind_interface'),
8808            egress_filter=d.get('egress_filter'),
8809            endpoint=d.get('endpoint'),
8810            healthy=d.get('healthy'),
8811            id=d.get('id'),
8812            name=d.get('name'),
8813            port=d.get('port'),
8814            port_override=d.get('port_override'),
8815            secret_store_id=d.get('secret_store_id'),
8816            tags=d.get('tags'),
8817        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8722    def __init__(
8723        self,
8724        bind_interface=None,
8725        egress_filter=None,
8726        endpoint=None,
8727        healthy=None,
8728        id=None,
8729        name=None,
8730        port=None,
8731        port_override=None,
8732        secret_store_id=None,
8733        tags=None,
8734    ):
8735        self.bind_interface = bind_interface if bind_interface is not None else ''
8736        '''
8737         Bind interface
8738        '''
8739        self.egress_filter = egress_filter if egress_filter is not None else ''
8740        '''
8741         A filter applied to the routing logic to pin datasource to nodes.
8742        '''
8743        self.endpoint = endpoint if endpoint is not None else ''
8744        '''
8745
8746        '''
8747        self.healthy = healthy if healthy is not None else False
8748        '''
8749         True if the datasource is reachable and the credentials are valid.
8750        '''
8751        self.id = id if id is not None else ''
8752        '''
8753         Unique identifier of the Resource.
8754        '''
8755        self.name = name if name is not None else ''
8756        '''
8757         Unique human-readable name of the Resource.
8758        '''
8759        self.port = port if port is not None else 0
8760        '''
8761
8762        '''
8763        self.port_override = port_override if port_override is not None else 0
8764        '''
8765
8766        '''
8767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8768        '''
8769         ID of the secret store containing credentials for this resource, if any.
8770        '''
8771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8772        '''
8773         Tags is a map of key, value pairs.
8774        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8790    def to_dict(self):
8791        return {
8792            'bind_interface': self.bind_interface,
8793            'egress_filter': self.egress_filter,
8794            'endpoint': self.endpoint,
8795            'healthy': self.healthy,
8796            'id': self.id,
8797            'name': self.name,
8798            'port': self.port,
8799            'port_override': self.port_override,
8800            'secret_store_id': self.secret_store_id,
8801            'tags': self.tags,
8802        }
@classmethod
def from_dict(cls, d)
8804    @classmethod
8805    def from_dict(cls, d):
8806        return cls(
8807            bind_interface=d.get('bind_interface'),
8808            egress_filter=d.get('egress_filter'),
8809            endpoint=d.get('endpoint'),
8810            healthy=d.get('healthy'),
8811            id=d.get('id'),
8812            name=d.get('name'),
8813            port=d.get('port'),
8814            port_override=d.get('port_override'),
8815            secret_store_id=d.get('secret_store_id'),
8816            tags=d.get('tags'),
8817        )
class NeptuneIAM:
8820class NeptuneIAM:
8821    '''
8822
8823    '''
8824    __slots__ = [
8825        'access_key',
8826        'bind_interface',
8827        'egress_filter',
8828        'endpoint',
8829        'healthy',
8830        'id',
8831        'name',
8832        'port',
8833        'port_override',
8834        'region',
8835        'role_arn',
8836        'role_external_id',
8837        'secret_access_key',
8838        'secret_store_id',
8839        'tags',
8840    ]
8841
8842    def __init__(
8843        self,
8844        access_key=None,
8845        bind_interface=None,
8846        egress_filter=None,
8847        endpoint=None,
8848        healthy=None,
8849        id=None,
8850        name=None,
8851        port=None,
8852        port_override=None,
8853        region=None,
8854        role_arn=None,
8855        role_external_id=None,
8856        secret_access_key=None,
8857        secret_store_id=None,
8858        tags=None,
8859    ):
8860        self.access_key = access_key if access_key is not None else ''
8861        '''
8862
8863        '''
8864        self.bind_interface = bind_interface if bind_interface is not None else ''
8865        '''
8866         Bind interface
8867        '''
8868        self.egress_filter = egress_filter if egress_filter is not None else ''
8869        '''
8870         A filter applied to the routing logic to pin datasource to nodes.
8871        '''
8872        self.endpoint = endpoint if endpoint is not None else ''
8873        '''
8874
8875        '''
8876        self.healthy = healthy if healthy is not None else False
8877        '''
8878         True if the datasource is reachable and the credentials are valid.
8879        '''
8880        self.id = id if id is not None else ''
8881        '''
8882         Unique identifier of the Resource.
8883        '''
8884        self.name = name if name is not None else ''
8885        '''
8886         Unique human-readable name of the Resource.
8887        '''
8888        self.port = port if port is not None else 0
8889        '''
8890
8891        '''
8892        self.port_override = port_override if port_override is not None else 0
8893        '''
8894
8895        '''
8896        self.region = region if region is not None else ''
8897        '''
8898
8899        '''
8900        self.role_arn = role_arn if role_arn is not None else ''
8901        '''
8902
8903        '''
8904        self.role_external_id = role_external_id if role_external_id is not None else ''
8905        '''
8906
8907        '''
8908        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8909        '''
8910
8911        '''
8912        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8913        '''
8914         ID of the secret store containing credentials for this resource, if any.
8915        '''
8916        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8917        '''
8918         Tags is a map of key, value pairs.
8919        '''
8920
8921    def __repr__(self):
8922        return '<sdm.NeptuneIAM ' + \
8923            'access_key: ' + repr(self.access_key) + ' ' +\
8924            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8925            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8926            'endpoint: ' + repr(self.endpoint) + ' ' +\
8927            'healthy: ' + repr(self.healthy) + ' ' +\
8928            'id: ' + repr(self.id) + ' ' +\
8929            'name: ' + repr(self.name) + ' ' +\
8930            'port: ' + repr(self.port) + ' ' +\
8931            'port_override: ' + repr(self.port_override) + ' ' +\
8932            'region: ' + repr(self.region) + ' ' +\
8933            'role_arn: ' + repr(self.role_arn) + ' ' +\
8934            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8935            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8936            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8937            'tags: ' + repr(self.tags) + ' ' +\
8938            '>'
8939
8940    def to_dict(self):
8941        return {
8942            'access_key': self.access_key,
8943            'bind_interface': self.bind_interface,
8944            'egress_filter': self.egress_filter,
8945            'endpoint': self.endpoint,
8946            'healthy': self.healthy,
8947            'id': self.id,
8948            'name': self.name,
8949            'port': self.port,
8950            'port_override': self.port_override,
8951            'region': self.region,
8952            'role_arn': self.role_arn,
8953            'role_external_id': self.role_external_id,
8954            'secret_access_key': self.secret_access_key,
8955            'secret_store_id': self.secret_store_id,
8956            'tags': self.tags,
8957        }
8958
8959    @classmethod
8960    def from_dict(cls, d):
8961        return cls(
8962            access_key=d.get('access_key'),
8963            bind_interface=d.get('bind_interface'),
8964            egress_filter=d.get('egress_filter'),
8965            endpoint=d.get('endpoint'),
8966            healthy=d.get('healthy'),
8967            id=d.get('id'),
8968            name=d.get('name'),
8969            port=d.get('port'),
8970            port_override=d.get('port_override'),
8971            region=d.get('region'),
8972            role_arn=d.get('role_arn'),
8973            role_external_id=d.get('role_external_id'),
8974            secret_access_key=d.get('secret_access_key'),
8975            secret_store_id=d.get('secret_store_id'),
8976            tags=d.get('tags'),
8977        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8842    def __init__(
8843        self,
8844        access_key=None,
8845        bind_interface=None,
8846        egress_filter=None,
8847        endpoint=None,
8848        healthy=None,
8849        id=None,
8850        name=None,
8851        port=None,
8852        port_override=None,
8853        region=None,
8854        role_arn=None,
8855        role_external_id=None,
8856        secret_access_key=None,
8857        secret_store_id=None,
8858        tags=None,
8859    ):
8860        self.access_key = access_key if access_key is not None else ''
8861        '''
8862
8863        '''
8864        self.bind_interface = bind_interface if bind_interface is not None else ''
8865        '''
8866         Bind interface
8867        '''
8868        self.egress_filter = egress_filter if egress_filter is not None else ''
8869        '''
8870         A filter applied to the routing logic to pin datasource to nodes.
8871        '''
8872        self.endpoint = endpoint if endpoint is not None else ''
8873        '''
8874
8875        '''
8876        self.healthy = healthy if healthy is not None else False
8877        '''
8878         True if the datasource is reachable and the credentials are valid.
8879        '''
8880        self.id = id if id is not None else ''
8881        '''
8882         Unique identifier of the Resource.
8883        '''
8884        self.name = name if name is not None else ''
8885        '''
8886         Unique human-readable name of the Resource.
8887        '''
8888        self.port = port if port is not None else 0
8889        '''
8890
8891        '''
8892        self.port_override = port_override if port_override is not None else 0
8893        '''
8894
8895        '''
8896        self.region = region if region is not None else ''
8897        '''
8898
8899        '''
8900        self.role_arn = role_arn if role_arn is not None else ''
8901        '''
8902
8903        '''
8904        self.role_external_id = role_external_id if role_external_id is not None else ''
8905        '''
8906
8907        '''
8908        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8909        '''
8910
8911        '''
8912        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8913        '''
8914         ID of the secret store containing credentials for this resource, if any.
8915        '''
8916        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8917        '''
8918         Tags is a map of key, value pairs.
8919        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8940    def to_dict(self):
8941        return {
8942            'access_key': self.access_key,
8943            'bind_interface': self.bind_interface,
8944            'egress_filter': self.egress_filter,
8945            'endpoint': self.endpoint,
8946            'healthy': self.healthy,
8947            'id': self.id,
8948            'name': self.name,
8949            'port': self.port,
8950            'port_override': self.port_override,
8951            'region': self.region,
8952            'role_arn': self.role_arn,
8953            'role_external_id': self.role_external_id,
8954            'secret_access_key': self.secret_access_key,
8955            'secret_store_id': self.secret_store_id,
8956            'tags': self.tags,
8957        }
@classmethod
def from_dict(cls, d)
8959    @classmethod
8960    def from_dict(cls, d):
8961        return cls(
8962            access_key=d.get('access_key'),
8963            bind_interface=d.get('bind_interface'),
8964            egress_filter=d.get('egress_filter'),
8965            endpoint=d.get('endpoint'),
8966            healthy=d.get('healthy'),
8967            id=d.get('id'),
8968            name=d.get('name'),
8969            port=d.get('port'),
8970            port_override=d.get('port_override'),
8971            region=d.get('region'),
8972            role_arn=d.get('role_arn'),
8973            role_external_id=d.get('role_external_id'),
8974            secret_access_key=d.get('secret_access_key'),
8975            secret_store_id=d.get('secret_store_id'),
8976            tags=d.get('tags'),
8977        )
class NodeCreateResponse:
8980class NodeCreateResponse:
8981    '''
8982     NodeCreateResponse reports how the Nodes were created in the system.
8983    '''
8984    __slots__ = [
8985        'meta',
8986        'node',
8987        'rate_limit',
8988        'token',
8989    ]
8990
8991    def __init__(
8992        self,
8993        meta=None,
8994        node=None,
8995        rate_limit=None,
8996        token=None,
8997    ):
8998        self.meta = meta if meta is not None else None
8999        '''
9000         Reserved for future use.
9001        '''
9002        self.node = node if node is not None else None
9003        '''
9004         The created Node.
9005        '''
9006        self.rate_limit = rate_limit if rate_limit is not None else None
9007        '''
9008         Rate limit information.
9009        '''
9010        self.token = token if token is not None else ''
9011        '''
9012         The auth token generated for the Node. The Node will use this token to
9013         authenticate with the strongDM API.
9014        '''
9015
9016    def __repr__(self):
9017        return '<sdm.NodeCreateResponse ' + \
9018            'meta: ' + repr(self.meta) + ' ' +\
9019            'node: ' + repr(self.node) + ' ' +\
9020            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9021            'token: ' + repr(self.token) + ' ' +\
9022            '>'
9023
9024    def to_dict(self):
9025        return {
9026            'meta': self.meta,
9027            'node': self.node,
9028            'rate_limit': self.rate_limit,
9029            'token': self.token,
9030        }
9031
9032    @classmethod
9033    def from_dict(cls, d):
9034        return cls(
9035            meta=d.get('meta'),
9036            node=d.get('node'),
9037            rate_limit=d.get('rate_limit'),
9038            token=d.get('token'),
9039        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8991    def __init__(
8992        self,
8993        meta=None,
8994        node=None,
8995        rate_limit=None,
8996        token=None,
8997    ):
8998        self.meta = meta if meta is not None else None
8999        '''
9000         Reserved for future use.
9001        '''
9002        self.node = node if node is not None else None
9003        '''
9004         The created Node.
9005        '''
9006        self.rate_limit = rate_limit if rate_limit is not None else None
9007        '''
9008         Rate limit information.
9009        '''
9010        self.token = token if token is not None else ''
9011        '''
9012         The auth token generated for the Node. The Node will use this token to
9013         authenticate with the strongDM API.
9014        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
9024    def to_dict(self):
9025        return {
9026            'meta': self.meta,
9027            'node': self.node,
9028            'rate_limit': self.rate_limit,
9029            'token': self.token,
9030        }
@classmethod
def from_dict(cls, d)
9032    @classmethod
9033    def from_dict(cls, d):
9034        return cls(
9035            meta=d.get('meta'),
9036            node=d.get('node'),
9037            rate_limit=d.get('rate_limit'),
9038            token=d.get('token'),
9039        )
class NodeDeleteResponse:
9042class NodeDeleteResponse:
9043    '''
9044     NodeDeleteResponse returns information about a Node that was deleted.
9045    '''
9046    __slots__ = [
9047        'meta',
9048        'rate_limit',
9049    ]
9050
9051    def __init__(
9052        self,
9053        meta=None,
9054        rate_limit=None,
9055    ):
9056        self.meta = meta if meta is not None else None
9057        '''
9058         Reserved for future use.
9059        '''
9060        self.rate_limit = rate_limit if rate_limit is not None else None
9061        '''
9062         Rate limit information.
9063        '''
9064
9065    def __repr__(self):
9066        return '<sdm.NodeDeleteResponse ' + \
9067            'meta: ' + repr(self.meta) + ' ' +\
9068            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9069            '>'
9070
9071    def to_dict(self):
9072        return {
9073            'meta': self.meta,
9074            'rate_limit': self.rate_limit,
9075        }
9076
9077    @classmethod
9078    def from_dict(cls, d):
9079        return cls(
9080            meta=d.get('meta'),
9081            rate_limit=d.get('rate_limit'),
9082        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
9051    def __init__(
9052        self,
9053        meta=None,
9054        rate_limit=None,
9055    ):
9056        self.meta = meta if meta is not None else None
9057        '''
9058         Reserved for future use.
9059        '''
9060        self.rate_limit = rate_limit if rate_limit is not None else None
9061        '''
9062         Rate limit information.
9063        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9071    def to_dict(self):
9072        return {
9073            'meta': self.meta,
9074            'rate_limit': self.rate_limit,
9075        }
@classmethod
def from_dict(cls, d)
9077    @classmethod
9078    def from_dict(cls, d):
9079        return cls(
9080            meta=d.get('meta'),
9081            rate_limit=d.get('rate_limit'),
9082        )
class NodeGetResponse:
9085class NodeGetResponse:
9086    '''
9087     NodeGetResponse returns a requested Node.
9088    '''
9089    __slots__ = [
9090        'meta',
9091        'node',
9092        'rate_limit',
9093    ]
9094
9095    def __init__(
9096        self,
9097        meta=None,
9098        node=None,
9099        rate_limit=None,
9100    ):
9101        self.meta = meta if meta is not None else None
9102        '''
9103         Reserved for future use.
9104        '''
9105        self.node = node if node is not None else None
9106        '''
9107         The requested Node.
9108        '''
9109        self.rate_limit = rate_limit if rate_limit is not None else None
9110        '''
9111         Rate limit information.
9112        '''
9113
9114    def __repr__(self):
9115        return '<sdm.NodeGetResponse ' + \
9116            'meta: ' + repr(self.meta) + ' ' +\
9117            'node: ' + repr(self.node) + ' ' +\
9118            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9119            '>'
9120
9121    def to_dict(self):
9122        return {
9123            'meta': self.meta,
9124            'node': self.node,
9125            'rate_limit': self.rate_limit,
9126        }
9127
9128    @classmethod
9129    def from_dict(cls, d):
9130        return cls(
9131            meta=d.get('meta'),
9132            node=d.get('node'),
9133            rate_limit=d.get('rate_limit'),
9134        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
9095    def __init__(
9096        self,
9097        meta=None,
9098        node=None,
9099        rate_limit=None,
9100    ):
9101        self.meta = meta if meta is not None else None
9102        '''
9103         Reserved for future use.
9104        '''
9105        self.node = node if node is not None else None
9106        '''
9107         The requested Node.
9108        '''
9109        self.rate_limit = rate_limit if rate_limit is not None else None
9110        '''
9111         Rate limit information.
9112        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
9121    def to_dict(self):
9122        return {
9123            'meta': self.meta,
9124            'node': self.node,
9125            'rate_limit': self.rate_limit,
9126        }
@classmethod
def from_dict(cls, d)
9128    @classmethod
9129    def from_dict(cls, d):
9130        return cls(
9131            meta=d.get('meta'),
9132            node=d.get('node'),
9133            rate_limit=d.get('rate_limit'),
9134        )
class NodeUpdateResponse:
9137class NodeUpdateResponse:
9138    '''
9139     NodeUpdateResponse returns the fields of a Node after it has been updated by
9140     a NodeUpdateRequest.
9141    '''
9142    __slots__ = [
9143        'meta',
9144        'node',
9145        'rate_limit',
9146    ]
9147
9148    def __init__(
9149        self,
9150        meta=None,
9151        node=None,
9152        rate_limit=None,
9153    ):
9154        self.meta = meta if meta is not None else None
9155        '''
9156         Reserved for future use.
9157        '''
9158        self.node = node if node is not None else None
9159        '''
9160         The updated Node.
9161        '''
9162        self.rate_limit = rate_limit if rate_limit is not None else None
9163        '''
9164         Rate limit information.
9165        '''
9166
9167    def __repr__(self):
9168        return '<sdm.NodeUpdateResponse ' + \
9169            'meta: ' + repr(self.meta) + ' ' +\
9170            'node: ' + repr(self.node) + ' ' +\
9171            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9172            '>'
9173
9174    def to_dict(self):
9175        return {
9176            'meta': self.meta,
9177            'node': self.node,
9178            'rate_limit': self.rate_limit,
9179        }
9180
9181    @classmethod
9182    def from_dict(cls, d):
9183        return cls(
9184            meta=d.get('meta'),
9185            node=d.get('node'),
9186            rate_limit=d.get('rate_limit'),
9187        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
9148    def __init__(
9149        self,
9150        meta=None,
9151        node=None,
9152        rate_limit=None,
9153    ):
9154        self.meta = meta if meta is not None else None
9155        '''
9156         Reserved for future use.
9157        '''
9158        self.node = node if node is not None else None
9159        '''
9160         The updated Node.
9161        '''
9162        self.rate_limit = rate_limit if rate_limit is not None else None
9163        '''
9164         Rate limit information.
9165        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
9174    def to_dict(self):
9175        return {
9176            'meta': self.meta,
9177            'node': self.node,
9178            'rate_limit': self.rate_limit,
9179        }
@classmethod
def from_dict(cls, d)
9181    @classmethod
9182    def from_dict(cls, d):
9183        return cls(
9184            meta=d.get('meta'),
9185            node=d.get('node'),
9186            rate_limit=d.get('rate_limit'),
9187        )
class Oracle:
9190class Oracle:
9191    '''
9192
9193    '''
9194    __slots__ = [
9195        'bind_interface',
9196        'database',
9197        'egress_filter',
9198        'healthy',
9199        'hostname',
9200        'id',
9201        'name',
9202        'password',
9203        'port',
9204        'port_override',
9205        'secret_store_id',
9206        'tags',
9207        'tls_required',
9208        'username',
9209    ]
9210
9211    def __init__(
9212        self,
9213        bind_interface=None,
9214        database=None,
9215        egress_filter=None,
9216        healthy=None,
9217        hostname=None,
9218        id=None,
9219        name=None,
9220        password=None,
9221        port=None,
9222        port_override=None,
9223        secret_store_id=None,
9224        tags=None,
9225        tls_required=None,
9226        username=None,
9227    ):
9228        self.bind_interface = bind_interface if bind_interface is not None else ''
9229        '''
9230         Bind interface
9231        '''
9232        self.database = database if database is not None else ''
9233        '''
9234
9235        '''
9236        self.egress_filter = egress_filter if egress_filter is not None else ''
9237        '''
9238         A filter applied to the routing logic to pin datasource to nodes.
9239        '''
9240        self.healthy = healthy if healthy is not None else False
9241        '''
9242         True if the datasource is reachable and the credentials are valid.
9243        '''
9244        self.hostname = hostname if hostname is not None else ''
9245        '''
9246
9247        '''
9248        self.id = id if id is not None else ''
9249        '''
9250         Unique identifier of the Resource.
9251        '''
9252        self.name = name if name is not None else ''
9253        '''
9254         Unique human-readable name of the Resource.
9255        '''
9256        self.password = password if password is not None else ''
9257        '''
9258
9259        '''
9260        self.port = port if port is not None else 0
9261        '''
9262
9263        '''
9264        self.port_override = port_override if port_override is not None else 0
9265        '''
9266
9267        '''
9268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9269        '''
9270         ID of the secret store containing credentials for this resource, if any.
9271        '''
9272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9273        '''
9274         Tags is a map of key, value pairs.
9275        '''
9276        self.tls_required = tls_required if tls_required is not None else False
9277        '''
9278
9279        '''
9280        self.username = username if username is not None else ''
9281        '''
9282
9283        '''
9284
9285    def __repr__(self):
9286        return '<sdm.Oracle ' + \
9287            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9288            'database: ' + repr(self.database) + ' ' +\
9289            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9290            'healthy: ' + repr(self.healthy) + ' ' +\
9291            'hostname: ' + repr(self.hostname) + ' ' +\
9292            'id: ' + repr(self.id) + ' ' +\
9293            'name: ' + repr(self.name) + ' ' +\
9294            'password: ' + repr(self.password) + ' ' +\
9295            'port: ' + repr(self.port) + ' ' +\
9296            'port_override: ' + repr(self.port_override) + ' ' +\
9297            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9298            'tags: ' + repr(self.tags) + ' ' +\
9299            'tls_required: ' + repr(self.tls_required) + ' ' +\
9300            'username: ' + repr(self.username) + ' ' +\
9301            '>'
9302
9303    def to_dict(self):
9304        return {
9305            'bind_interface': self.bind_interface,
9306            'database': self.database,
9307            'egress_filter': self.egress_filter,
9308            'healthy': self.healthy,
9309            'hostname': self.hostname,
9310            'id': self.id,
9311            'name': self.name,
9312            'password': self.password,
9313            'port': self.port,
9314            'port_override': self.port_override,
9315            'secret_store_id': self.secret_store_id,
9316            'tags': self.tags,
9317            'tls_required': self.tls_required,
9318            'username': self.username,
9319        }
9320
9321    @classmethod
9322    def from_dict(cls, d):
9323        return cls(
9324            bind_interface=d.get('bind_interface'),
9325            database=d.get('database'),
9326            egress_filter=d.get('egress_filter'),
9327            healthy=d.get('healthy'),
9328            hostname=d.get('hostname'),
9329            id=d.get('id'),
9330            name=d.get('name'),
9331            password=d.get('password'),
9332            port=d.get('port'),
9333            port_override=d.get('port_override'),
9334            secret_store_id=d.get('secret_store_id'),
9335            tags=d.get('tags'),
9336            tls_required=d.get('tls_required'),
9337            username=d.get('username'),
9338        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9211    def __init__(
9212        self,
9213        bind_interface=None,
9214        database=None,
9215        egress_filter=None,
9216        healthy=None,
9217        hostname=None,
9218        id=None,
9219        name=None,
9220        password=None,
9221        port=None,
9222        port_override=None,
9223        secret_store_id=None,
9224        tags=None,
9225        tls_required=None,
9226        username=None,
9227    ):
9228        self.bind_interface = bind_interface if bind_interface is not None else ''
9229        '''
9230         Bind interface
9231        '''
9232        self.database = database if database is not None else ''
9233        '''
9234
9235        '''
9236        self.egress_filter = egress_filter if egress_filter is not None else ''
9237        '''
9238         A filter applied to the routing logic to pin datasource to nodes.
9239        '''
9240        self.healthy = healthy if healthy is not None else False
9241        '''
9242         True if the datasource is reachable and the credentials are valid.
9243        '''
9244        self.hostname = hostname if hostname is not None else ''
9245        '''
9246
9247        '''
9248        self.id = id if id is not None else ''
9249        '''
9250         Unique identifier of the Resource.
9251        '''
9252        self.name = name if name is not None else ''
9253        '''
9254         Unique human-readable name of the Resource.
9255        '''
9256        self.password = password if password is not None else ''
9257        '''
9258
9259        '''
9260        self.port = port if port is not None else 0
9261        '''
9262
9263        '''
9264        self.port_override = port_override if port_override is not None else 0
9265        '''
9266
9267        '''
9268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9269        '''
9270         ID of the secret store containing credentials for this resource, if any.
9271        '''
9272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9273        '''
9274         Tags is a map of key, value pairs.
9275        '''
9276        self.tls_required = tls_required if tls_required is not None else False
9277        '''
9278
9279        '''
9280        self.username = username if username is not None else ''
9281        '''
9282
9283        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9303    def to_dict(self):
9304        return {
9305            'bind_interface': self.bind_interface,
9306            'database': self.database,
9307            'egress_filter': self.egress_filter,
9308            'healthy': self.healthy,
9309            'hostname': self.hostname,
9310            'id': self.id,
9311            'name': self.name,
9312            'password': self.password,
9313            'port': self.port,
9314            'port_override': self.port_override,
9315            'secret_store_id': self.secret_store_id,
9316            'tags': self.tags,
9317            'tls_required': self.tls_required,
9318            'username': self.username,
9319        }
@classmethod
def from_dict(cls, d)
9321    @classmethod
9322    def from_dict(cls, d):
9323        return cls(
9324            bind_interface=d.get('bind_interface'),
9325            database=d.get('database'),
9326            egress_filter=d.get('egress_filter'),
9327            healthy=d.get('healthy'),
9328            hostname=d.get('hostname'),
9329            id=d.get('id'),
9330            name=d.get('name'),
9331            password=d.get('password'),
9332            port=d.get('port'),
9333            port_override=d.get('port_override'),
9334            secret_store_id=d.get('secret_store_id'),
9335            tags=d.get('tags'),
9336            tls_required=d.get('tls_required'),
9337            username=d.get('username'),
9338        )
class Postgres:
9341class Postgres:
9342    '''
9343
9344    '''
9345    __slots__ = [
9346        'bind_interface',
9347        'database',
9348        'egress_filter',
9349        'healthy',
9350        'hostname',
9351        'id',
9352        'name',
9353        'override_database',
9354        'password',
9355        'port',
9356        'port_override',
9357        'secret_store_id',
9358        'tags',
9359        'username',
9360    ]
9361
9362    def __init__(
9363        self,
9364        bind_interface=None,
9365        database=None,
9366        egress_filter=None,
9367        healthy=None,
9368        hostname=None,
9369        id=None,
9370        name=None,
9371        override_database=None,
9372        password=None,
9373        port=None,
9374        port_override=None,
9375        secret_store_id=None,
9376        tags=None,
9377        username=None,
9378    ):
9379        self.bind_interface = bind_interface if bind_interface is not None else ''
9380        '''
9381         Bind interface
9382        '''
9383        self.database = database if database is not None else ''
9384        '''
9385
9386        '''
9387        self.egress_filter = egress_filter if egress_filter is not None else ''
9388        '''
9389         A filter applied to the routing logic to pin datasource to nodes.
9390        '''
9391        self.healthy = healthy if healthy is not None else False
9392        '''
9393         True if the datasource is reachable and the credentials are valid.
9394        '''
9395        self.hostname = hostname if hostname is not None else ''
9396        '''
9397
9398        '''
9399        self.id = id if id is not None else ''
9400        '''
9401         Unique identifier of the Resource.
9402        '''
9403        self.name = name if name is not None else ''
9404        '''
9405         Unique human-readable name of the Resource.
9406        '''
9407        self.override_database = override_database if override_database is not None else False
9408        '''
9409
9410        '''
9411        self.password = password if password is not None else ''
9412        '''
9413
9414        '''
9415        self.port = port if port is not None else 0
9416        '''
9417
9418        '''
9419        self.port_override = port_override if port_override is not None else 0
9420        '''
9421
9422        '''
9423        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9424        '''
9425         ID of the secret store containing credentials for this resource, if any.
9426        '''
9427        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9428        '''
9429         Tags is a map of key, value pairs.
9430        '''
9431        self.username = username if username is not None else ''
9432        '''
9433
9434        '''
9435
9436    def __repr__(self):
9437        return '<sdm.Postgres ' + \
9438            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9439            'database: ' + repr(self.database) + ' ' +\
9440            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9441            'healthy: ' + repr(self.healthy) + ' ' +\
9442            'hostname: ' + repr(self.hostname) + ' ' +\
9443            'id: ' + repr(self.id) + ' ' +\
9444            'name: ' + repr(self.name) + ' ' +\
9445            'override_database: ' + repr(self.override_database) + ' ' +\
9446            'password: ' + repr(self.password) + ' ' +\
9447            'port: ' + repr(self.port) + ' ' +\
9448            'port_override: ' + repr(self.port_override) + ' ' +\
9449            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9450            'tags: ' + repr(self.tags) + ' ' +\
9451            'username: ' + repr(self.username) + ' ' +\
9452            '>'
9453
9454    def to_dict(self):
9455        return {
9456            'bind_interface': self.bind_interface,
9457            'database': self.database,
9458            'egress_filter': self.egress_filter,
9459            'healthy': self.healthy,
9460            'hostname': self.hostname,
9461            'id': self.id,
9462            'name': self.name,
9463            'override_database': self.override_database,
9464            'password': self.password,
9465            'port': self.port,
9466            'port_override': self.port_override,
9467            'secret_store_id': self.secret_store_id,
9468            'tags': self.tags,
9469            'username': self.username,
9470        }
9471
9472    @classmethod
9473    def from_dict(cls, d):
9474        return cls(
9475            bind_interface=d.get('bind_interface'),
9476            database=d.get('database'),
9477            egress_filter=d.get('egress_filter'),
9478            healthy=d.get('healthy'),
9479            hostname=d.get('hostname'),
9480            id=d.get('id'),
9481            name=d.get('name'),
9482            override_database=d.get('override_database'),
9483            password=d.get('password'),
9484            port=d.get('port'),
9485            port_override=d.get('port_override'),
9486            secret_store_id=d.get('secret_store_id'),
9487            tags=d.get('tags'),
9488            username=d.get('username'),
9489        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9362    def __init__(
9363        self,
9364        bind_interface=None,
9365        database=None,
9366        egress_filter=None,
9367        healthy=None,
9368        hostname=None,
9369        id=None,
9370        name=None,
9371        override_database=None,
9372        password=None,
9373        port=None,
9374        port_override=None,
9375        secret_store_id=None,
9376        tags=None,
9377        username=None,
9378    ):
9379        self.bind_interface = bind_interface if bind_interface is not None else ''
9380        '''
9381         Bind interface
9382        '''
9383        self.database = database if database is not None else ''
9384        '''
9385
9386        '''
9387        self.egress_filter = egress_filter if egress_filter is not None else ''
9388        '''
9389         A filter applied to the routing logic to pin datasource to nodes.
9390        '''
9391        self.healthy = healthy if healthy is not None else False
9392        '''
9393         True if the datasource is reachable and the credentials are valid.
9394        '''
9395        self.hostname = hostname if hostname is not None else ''
9396        '''
9397
9398        '''
9399        self.id = id if id is not None else ''
9400        '''
9401         Unique identifier of the Resource.
9402        '''
9403        self.name = name if name is not None else ''
9404        '''
9405         Unique human-readable name of the Resource.
9406        '''
9407        self.override_database = override_database if override_database is not None else False
9408        '''
9409
9410        '''
9411        self.password = password if password is not None else ''
9412        '''
9413
9414        '''
9415        self.port = port if port is not None else 0
9416        '''
9417
9418        '''
9419        self.port_override = port_override if port_override is not None else 0
9420        '''
9421
9422        '''
9423        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9424        '''
9425         ID of the secret store containing credentials for this resource, if any.
9426        '''
9427        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9428        '''
9429         Tags is a map of key, value pairs.
9430        '''
9431        self.username = username if username is not None else ''
9432        '''
9433
9434        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9454    def to_dict(self):
9455        return {
9456            'bind_interface': self.bind_interface,
9457            'database': self.database,
9458            'egress_filter': self.egress_filter,
9459            'healthy': self.healthy,
9460            'hostname': self.hostname,
9461            'id': self.id,
9462            'name': self.name,
9463            'override_database': self.override_database,
9464            'password': self.password,
9465            'port': self.port,
9466            'port_override': self.port_override,
9467            'secret_store_id': self.secret_store_id,
9468            'tags': self.tags,
9469            'username': self.username,
9470        }
@classmethod
def from_dict(cls, d)
9472    @classmethod
9473    def from_dict(cls, d):
9474        return cls(
9475            bind_interface=d.get('bind_interface'),
9476            database=d.get('database'),
9477            egress_filter=d.get('egress_filter'),
9478            healthy=d.get('healthy'),
9479            hostname=d.get('hostname'),
9480            id=d.get('id'),
9481            name=d.get('name'),
9482            override_database=d.get('override_database'),
9483            password=d.get('password'),
9484            port=d.get('port'),
9485            port_override=d.get('port_override'),
9486            secret_store_id=d.get('secret_store_id'),
9487            tags=d.get('tags'),
9488            username=d.get('username'),
9489        )
class Presto:
9492class Presto:
9493    '''
9494
9495    '''
9496    __slots__ = [
9497        'bind_interface',
9498        'database',
9499        'egress_filter',
9500        'healthy',
9501        'hostname',
9502        'id',
9503        'name',
9504        'password',
9505        'port',
9506        'port_override',
9507        'secret_store_id',
9508        'tags',
9509        'tls_required',
9510        'username',
9511    ]
9512
9513    def __init__(
9514        self,
9515        bind_interface=None,
9516        database=None,
9517        egress_filter=None,
9518        healthy=None,
9519        hostname=None,
9520        id=None,
9521        name=None,
9522        password=None,
9523        port=None,
9524        port_override=None,
9525        secret_store_id=None,
9526        tags=None,
9527        tls_required=None,
9528        username=None,
9529    ):
9530        self.bind_interface = bind_interface if bind_interface is not None else ''
9531        '''
9532         Bind interface
9533        '''
9534        self.database = database if database is not None else ''
9535        '''
9536
9537        '''
9538        self.egress_filter = egress_filter if egress_filter is not None else ''
9539        '''
9540         A filter applied to the routing logic to pin datasource to nodes.
9541        '''
9542        self.healthy = healthy if healthy is not None else False
9543        '''
9544         True if the datasource is reachable and the credentials are valid.
9545        '''
9546        self.hostname = hostname if hostname is not None else ''
9547        '''
9548
9549        '''
9550        self.id = id if id is not None else ''
9551        '''
9552         Unique identifier of the Resource.
9553        '''
9554        self.name = name if name is not None else ''
9555        '''
9556         Unique human-readable name of the Resource.
9557        '''
9558        self.password = password if password is not None else ''
9559        '''
9560
9561        '''
9562        self.port = port if port is not None else 0
9563        '''
9564
9565        '''
9566        self.port_override = port_override if port_override is not None else 0
9567        '''
9568
9569        '''
9570        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9571        '''
9572         ID of the secret store containing credentials for this resource, if any.
9573        '''
9574        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9575        '''
9576         Tags is a map of key, value pairs.
9577        '''
9578        self.tls_required = tls_required if tls_required is not None else False
9579        '''
9580
9581        '''
9582        self.username = username if username is not None else ''
9583        '''
9584
9585        '''
9586
9587    def __repr__(self):
9588        return '<sdm.Presto ' + \
9589            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9590            'database: ' + repr(self.database) + ' ' +\
9591            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9592            'healthy: ' + repr(self.healthy) + ' ' +\
9593            'hostname: ' + repr(self.hostname) + ' ' +\
9594            'id: ' + repr(self.id) + ' ' +\
9595            'name: ' + repr(self.name) + ' ' +\
9596            'password: ' + repr(self.password) + ' ' +\
9597            'port: ' + repr(self.port) + ' ' +\
9598            'port_override: ' + repr(self.port_override) + ' ' +\
9599            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9600            'tags: ' + repr(self.tags) + ' ' +\
9601            'tls_required: ' + repr(self.tls_required) + ' ' +\
9602            'username: ' + repr(self.username) + ' ' +\
9603            '>'
9604
9605    def to_dict(self):
9606        return {
9607            'bind_interface': self.bind_interface,
9608            'database': self.database,
9609            'egress_filter': self.egress_filter,
9610            'healthy': self.healthy,
9611            'hostname': self.hostname,
9612            'id': self.id,
9613            'name': self.name,
9614            'password': self.password,
9615            'port': self.port,
9616            'port_override': self.port_override,
9617            'secret_store_id': self.secret_store_id,
9618            'tags': self.tags,
9619            'tls_required': self.tls_required,
9620            'username': self.username,
9621        }
9622
9623    @classmethod
9624    def from_dict(cls, d):
9625        return cls(
9626            bind_interface=d.get('bind_interface'),
9627            database=d.get('database'),
9628            egress_filter=d.get('egress_filter'),
9629            healthy=d.get('healthy'),
9630            hostname=d.get('hostname'),
9631            id=d.get('id'),
9632            name=d.get('name'),
9633            password=d.get('password'),
9634            port=d.get('port'),
9635            port_override=d.get('port_override'),
9636            secret_store_id=d.get('secret_store_id'),
9637            tags=d.get('tags'),
9638            tls_required=d.get('tls_required'),
9639            username=d.get('username'),
9640        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9513    def __init__(
9514        self,
9515        bind_interface=None,
9516        database=None,
9517        egress_filter=None,
9518        healthy=None,
9519        hostname=None,
9520        id=None,
9521        name=None,
9522        password=None,
9523        port=None,
9524        port_override=None,
9525        secret_store_id=None,
9526        tags=None,
9527        tls_required=None,
9528        username=None,
9529    ):
9530        self.bind_interface = bind_interface if bind_interface is not None else ''
9531        '''
9532         Bind interface
9533        '''
9534        self.database = database if database is not None else ''
9535        '''
9536
9537        '''
9538        self.egress_filter = egress_filter if egress_filter is not None else ''
9539        '''
9540         A filter applied to the routing logic to pin datasource to nodes.
9541        '''
9542        self.healthy = healthy if healthy is not None else False
9543        '''
9544         True if the datasource is reachable and the credentials are valid.
9545        '''
9546        self.hostname = hostname if hostname is not None else ''
9547        '''
9548
9549        '''
9550        self.id = id if id is not None else ''
9551        '''
9552         Unique identifier of the Resource.
9553        '''
9554        self.name = name if name is not None else ''
9555        '''
9556         Unique human-readable name of the Resource.
9557        '''
9558        self.password = password if password is not None else ''
9559        '''
9560
9561        '''
9562        self.port = port if port is not None else 0
9563        '''
9564
9565        '''
9566        self.port_override = port_override if port_override is not None else 0
9567        '''
9568
9569        '''
9570        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9571        '''
9572         ID of the secret store containing credentials for this resource, if any.
9573        '''
9574        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9575        '''
9576         Tags is a map of key, value pairs.
9577        '''
9578        self.tls_required = tls_required if tls_required is not None else False
9579        '''
9580
9581        '''
9582        self.username = username if username is not None else ''
9583        '''
9584
9585        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9605    def to_dict(self):
9606        return {
9607            'bind_interface': self.bind_interface,
9608            'database': self.database,
9609            'egress_filter': self.egress_filter,
9610            'healthy': self.healthy,
9611            'hostname': self.hostname,
9612            'id': self.id,
9613            'name': self.name,
9614            'password': self.password,
9615            'port': self.port,
9616            'port_override': self.port_override,
9617            'secret_store_id': self.secret_store_id,
9618            'tags': self.tags,
9619            'tls_required': self.tls_required,
9620            'username': self.username,
9621        }
@classmethod
def from_dict(cls, d)
9623    @classmethod
9624    def from_dict(cls, d):
9625        return cls(
9626            bind_interface=d.get('bind_interface'),
9627            database=d.get('database'),
9628            egress_filter=d.get('egress_filter'),
9629            healthy=d.get('healthy'),
9630            hostname=d.get('hostname'),
9631            id=d.get('id'),
9632            name=d.get('name'),
9633            password=d.get('password'),
9634            port=d.get('port'),
9635            port_override=d.get('port_override'),
9636            secret_store_id=d.get('secret_store_id'),
9637            tags=d.get('tags'),
9638            tls_required=d.get('tls_required'),
9639            username=d.get('username'),
9640        )
class RDP:
9643class RDP:
9644    '''
9645
9646    '''
9647    __slots__ = [
9648        'bind_interface',
9649        'downgrade_nla_connections',
9650        'egress_filter',
9651        'healthy',
9652        'hostname',
9653        'id',
9654        'name',
9655        'password',
9656        'port',
9657        'port_override',
9658        'secret_store_id',
9659        'tags',
9660        'username',
9661    ]
9662
9663    def __init__(
9664        self,
9665        bind_interface=None,
9666        downgrade_nla_connections=None,
9667        egress_filter=None,
9668        healthy=None,
9669        hostname=None,
9670        id=None,
9671        name=None,
9672        password=None,
9673        port=None,
9674        port_override=None,
9675        secret_store_id=None,
9676        tags=None,
9677        username=None,
9678    ):
9679        self.bind_interface = bind_interface if bind_interface is not None else ''
9680        '''
9681         Bind interface
9682        '''
9683        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9684        '''
9685
9686        '''
9687        self.egress_filter = egress_filter if egress_filter is not None else ''
9688        '''
9689         A filter applied to the routing logic to pin datasource to nodes.
9690        '''
9691        self.healthy = healthy if healthy is not None else False
9692        '''
9693         True if the datasource is reachable and the credentials are valid.
9694        '''
9695        self.hostname = hostname if hostname is not None else ''
9696        '''
9697
9698        '''
9699        self.id = id if id is not None else ''
9700        '''
9701         Unique identifier of the Resource.
9702        '''
9703        self.name = name if name is not None else ''
9704        '''
9705         Unique human-readable name of the Resource.
9706        '''
9707        self.password = password if password is not None else ''
9708        '''
9709
9710        '''
9711        self.port = port if port is not None else 0
9712        '''
9713
9714        '''
9715        self.port_override = port_override if port_override is not None else 0
9716        '''
9717
9718        '''
9719        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9720        '''
9721         ID of the secret store containing credentials for this resource, if any.
9722        '''
9723        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9724        '''
9725         Tags is a map of key, value pairs.
9726        '''
9727        self.username = username if username is not None else ''
9728        '''
9729
9730        '''
9731
9732    def __repr__(self):
9733        return '<sdm.RDP ' + \
9734            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9735            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9736            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9737            'healthy: ' + repr(self.healthy) + ' ' +\
9738            'hostname: ' + repr(self.hostname) + ' ' +\
9739            'id: ' + repr(self.id) + ' ' +\
9740            'name: ' + repr(self.name) + ' ' +\
9741            'password: ' + repr(self.password) + ' ' +\
9742            'port: ' + repr(self.port) + ' ' +\
9743            'port_override: ' + repr(self.port_override) + ' ' +\
9744            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9745            'tags: ' + repr(self.tags) + ' ' +\
9746            'username: ' + repr(self.username) + ' ' +\
9747            '>'
9748
9749    def to_dict(self):
9750        return {
9751            'bind_interface': self.bind_interface,
9752            'downgrade_nla_connections': self.downgrade_nla_connections,
9753            'egress_filter': self.egress_filter,
9754            'healthy': self.healthy,
9755            'hostname': self.hostname,
9756            'id': self.id,
9757            'name': self.name,
9758            'password': self.password,
9759            'port': self.port,
9760            'port_override': self.port_override,
9761            'secret_store_id': self.secret_store_id,
9762            'tags': self.tags,
9763            'username': self.username,
9764        }
9765
9766    @classmethod
9767    def from_dict(cls, d):
9768        return cls(
9769            bind_interface=d.get('bind_interface'),
9770            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9771            egress_filter=d.get('egress_filter'),
9772            healthy=d.get('healthy'),
9773            hostname=d.get('hostname'),
9774            id=d.get('id'),
9775            name=d.get('name'),
9776            password=d.get('password'),
9777            port=d.get('port'),
9778            port_override=d.get('port_override'),
9779            secret_store_id=d.get('secret_store_id'),
9780            tags=d.get('tags'),
9781            username=d.get('username'),
9782        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9663    def __init__(
9664        self,
9665        bind_interface=None,
9666        downgrade_nla_connections=None,
9667        egress_filter=None,
9668        healthy=None,
9669        hostname=None,
9670        id=None,
9671        name=None,
9672        password=None,
9673        port=None,
9674        port_override=None,
9675        secret_store_id=None,
9676        tags=None,
9677        username=None,
9678    ):
9679        self.bind_interface = bind_interface if bind_interface is not None else ''
9680        '''
9681         Bind interface
9682        '''
9683        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9684        '''
9685
9686        '''
9687        self.egress_filter = egress_filter if egress_filter is not None else ''
9688        '''
9689         A filter applied to the routing logic to pin datasource to nodes.
9690        '''
9691        self.healthy = healthy if healthy is not None else False
9692        '''
9693         True if the datasource is reachable and the credentials are valid.
9694        '''
9695        self.hostname = hostname if hostname is not None else ''
9696        '''
9697
9698        '''
9699        self.id = id if id is not None else ''
9700        '''
9701         Unique identifier of the Resource.
9702        '''
9703        self.name = name if name is not None else ''
9704        '''
9705         Unique human-readable name of the Resource.
9706        '''
9707        self.password = password if password is not None else ''
9708        '''
9709
9710        '''
9711        self.port = port if port is not None else 0
9712        '''
9713
9714        '''
9715        self.port_override = port_override if port_override is not None else 0
9716        '''
9717
9718        '''
9719        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9720        '''
9721         ID of the secret store containing credentials for this resource, if any.
9722        '''
9723        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9724        '''
9725         Tags is a map of key, value pairs.
9726        '''
9727        self.username = username if username is not None else ''
9728        '''
9729
9730        '''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9749    def to_dict(self):
9750        return {
9751            'bind_interface': self.bind_interface,
9752            'downgrade_nla_connections': self.downgrade_nla_connections,
9753            'egress_filter': self.egress_filter,
9754            'healthy': self.healthy,
9755            'hostname': self.hostname,
9756            'id': self.id,
9757            'name': self.name,
9758            'password': self.password,
9759            'port': self.port,
9760            'port_override': self.port_override,
9761            'secret_store_id': self.secret_store_id,
9762            'tags': self.tags,
9763            'username': self.username,
9764        }
@classmethod
def from_dict(cls, d)
9766    @classmethod
9767    def from_dict(cls, d):
9768        return cls(
9769            bind_interface=d.get('bind_interface'),
9770            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9771            egress_filter=d.get('egress_filter'),
9772            healthy=d.get('healthy'),
9773            hostname=d.get('hostname'),
9774            id=d.get('id'),
9775            name=d.get('name'),
9776            password=d.get('password'),
9777            port=d.get('port'),
9778            port_override=d.get('port_override'),
9779            secret_store_id=d.get('secret_store_id'),
9780            tags=d.get('tags'),
9781            username=d.get('username'),
9782        )
class RabbitMQAMQP091:
9785class RabbitMQAMQP091:
9786    '''
9787
9788    '''
9789    __slots__ = [
9790        'bind_interface',
9791        'egress_filter',
9792        'healthy',
9793        'hostname',
9794        'id',
9795        'name',
9796        'password',
9797        'port',
9798        'port_override',
9799        'secret_store_id',
9800        'tags',
9801        'tls_required',
9802        'username',
9803    ]
9804
9805    def __init__(
9806        self,
9807        bind_interface=None,
9808        egress_filter=None,
9809        healthy=None,
9810        hostname=None,
9811        id=None,
9812        name=None,
9813        password=None,
9814        port=None,
9815        port_override=None,
9816        secret_store_id=None,
9817        tags=None,
9818        tls_required=None,
9819        username=None,
9820    ):
9821        self.bind_interface = bind_interface if bind_interface is not None else ''
9822        '''
9823         Bind interface
9824        '''
9825        self.egress_filter = egress_filter if egress_filter is not None else ''
9826        '''
9827         A filter applied to the routing logic to pin datasource to nodes.
9828        '''
9829        self.healthy = healthy if healthy is not None else False
9830        '''
9831         True if the datasource is reachable and the credentials are valid.
9832        '''
9833        self.hostname = hostname if hostname is not None else ''
9834        '''
9835
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Resource.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Resource.
9844        '''
9845        self.password = password if password is not None else ''
9846        '''
9847
9848        '''
9849        self.port = port if port is not None else 0
9850        '''
9851
9852        '''
9853        self.port_override = port_override if port_override is not None else 0
9854        '''
9855
9856        '''
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.tls_required = tls_required if tls_required is not None else False
9866        '''
9867
9868        '''
9869        self.username = username if username is not None else ''
9870        '''
9871
9872        '''
9873
9874    def __repr__(self):
9875        return '<sdm.RabbitMQAMQP091 ' + \
9876            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9877            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9878            'healthy: ' + repr(self.healthy) + ' ' +\
9879            'hostname: ' + repr(self.hostname) + ' ' +\
9880            'id: ' + repr(self.id) + ' ' +\
9881            'name: ' + repr(self.name) + ' ' +\
9882            'password: ' + repr(self.password) + ' ' +\
9883            'port: ' + repr(self.port) + ' ' +\
9884            'port_override: ' + repr(self.port_override) + ' ' +\
9885            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9886            'tags: ' + repr(self.tags) + ' ' +\
9887            'tls_required: ' + repr(self.tls_required) + ' ' +\
9888            'username: ' + repr(self.username) + ' ' +\
9889            '>'
9890
9891    def to_dict(self):
9892        return {
9893            'bind_interface': self.bind_interface,
9894            'egress_filter': self.egress_filter,
9895            'healthy': self.healthy,
9896            'hostname': self.hostname,
9897            'id': self.id,
9898            'name': self.name,
9899            'password': self.password,
9900            'port': self.port,
9901            'port_override': self.port_override,
9902            'secret_store_id': self.secret_store_id,
9903            'tags': self.tags,
9904            'tls_required': self.tls_required,
9905            'username': self.username,
9906        }
9907
9908    @classmethod
9909    def from_dict(cls, d):
9910        return cls(
9911            bind_interface=d.get('bind_interface'),
9912            egress_filter=d.get('egress_filter'),
9913            healthy=d.get('healthy'),
9914            hostname=d.get('hostname'),
9915            id=d.get('id'),
9916            name=d.get('name'),
9917            password=d.get('password'),
9918            port=d.get('port'),
9919            port_override=d.get('port_override'),
9920            secret_store_id=d.get('secret_store_id'),
9921            tags=d.get('tags'),
9922            tls_required=d.get('tls_required'),
9923            username=d.get('username'),
9924        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9805    def __init__(
9806        self,
9807        bind_interface=None,
9808        egress_filter=None,
9809        healthy=None,
9810        hostname=None,
9811        id=None,
9812        name=None,
9813        password=None,
9814        port=None,
9815        port_override=None,
9816        secret_store_id=None,
9817        tags=None,
9818        tls_required=None,
9819        username=None,
9820    ):
9821        self.bind_interface = bind_interface if bind_interface is not None else ''
9822        '''
9823         Bind interface
9824        '''
9825        self.egress_filter = egress_filter if egress_filter is not None else ''
9826        '''
9827         A filter applied to the routing logic to pin datasource to nodes.
9828        '''
9829        self.healthy = healthy if healthy is not None else False
9830        '''
9831         True if the datasource is reachable and the credentials are valid.
9832        '''
9833        self.hostname = hostname if hostname is not None else ''
9834        '''
9835
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Resource.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Resource.
9844        '''
9845        self.password = password if password is not None else ''
9846        '''
9847
9848        '''
9849        self.port = port if port is not None else 0
9850        '''
9851
9852        '''
9853        self.port_override = port_override if port_override is not None else 0
9854        '''
9855
9856        '''
9857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9858        '''
9859         ID of the secret store containing credentials for this resource, if any.
9860        '''
9861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9862        '''
9863         Tags is a map of key, value pairs.
9864        '''
9865        self.tls_required = tls_required if tls_required is not None else False
9866        '''
9867
9868        '''
9869        self.username = username if username is not None else ''
9870        '''
9871
9872        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9891    def to_dict(self):
9892        return {
9893            'bind_interface': self.bind_interface,
9894            'egress_filter': self.egress_filter,
9895            'healthy': self.healthy,
9896            'hostname': self.hostname,
9897            'id': self.id,
9898            'name': self.name,
9899            'password': self.password,
9900            'port': self.port,
9901            'port_override': self.port_override,
9902            'secret_store_id': self.secret_store_id,
9903            'tags': self.tags,
9904            'tls_required': self.tls_required,
9905            'username': self.username,
9906        }
@classmethod
def from_dict(cls, d)
9908    @classmethod
9909    def from_dict(cls, d):
9910        return cls(
9911            bind_interface=d.get('bind_interface'),
9912            egress_filter=d.get('egress_filter'),
9913            healthy=d.get('healthy'),
9914            hostname=d.get('hostname'),
9915            id=d.get('id'),
9916            name=d.get('name'),
9917            password=d.get('password'),
9918            port=d.get('port'),
9919            port_override=d.get('port_override'),
9920            secret_store_id=d.get('secret_store_id'),
9921            tags=d.get('tags'),
9922            tls_required=d.get('tls_required'),
9923            username=d.get('username'),
9924        )
class RateLimitMetadata:
9927class RateLimitMetadata:
9928    '''
9929     RateLimitMetadata contains information about remaining requests avaialable
9930     to the user over some timeframe.
9931    '''
9932    __slots__ = [
9933        'bucket',
9934        'limit',
9935        'remaining',
9936        'reset_at',
9937    ]
9938
9939    def __init__(
9940        self,
9941        bucket=None,
9942        limit=None,
9943        remaining=None,
9944        reset_at=None,
9945    ):
9946        self.bucket = bucket if bucket is not None else ''
9947        '''
9948         The bucket this user/token is associated with, which may be shared between
9949         multiple users/tokens.
9950        '''
9951        self.limit = limit if limit is not None else 0
9952        '''
9953         How many total requests the user/token is authorized to make before being
9954         rate limited.
9955        '''
9956        self.remaining = remaining if remaining is not None else 0
9957        '''
9958         How many remaining requests out of the limit are still avaialable.
9959        '''
9960        self.reset_at = reset_at if reset_at is not None else None
9961        '''
9962         The time when remaining will be reset to limit.
9963        '''
9964
9965    def __repr__(self):
9966        return '<sdm.RateLimitMetadata ' + \
9967            'bucket: ' + repr(self.bucket) + ' ' +\
9968            'limit: ' + repr(self.limit) + ' ' +\
9969            'remaining: ' + repr(self.remaining) + ' ' +\
9970            'reset_at: ' + repr(self.reset_at) + ' ' +\
9971            '>'
9972
9973    def to_dict(self):
9974        return {
9975            'bucket': self.bucket,
9976            'limit': self.limit,
9977            'remaining': self.remaining,
9978            'reset_at': self.reset_at,
9979        }
9980
9981    @classmethod
9982    def from_dict(cls, d):
9983        return cls(
9984            bucket=d.get('bucket'),
9985            limit=d.get('limit'),
9986            remaining=d.get('remaining'),
9987            reset_at=d.get('reset_at'),
9988        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9939    def __init__(
9940        self,
9941        bucket=None,
9942        limit=None,
9943        remaining=None,
9944        reset_at=None,
9945    ):
9946        self.bucket = bucket if bucket is not None else ''
9947        '''
9948         The bucket this user/token is associated with, which may be shared between
9949         multiple users/tokens.
9950        '''
9951        self.limit = limit if limit is not None else 0
9952        '''
9953         How many total requests the user/token is authorized to make before being
9954         rate limited.
9955        '''
9956        self.remaining = remaining if remaining is not None else 0
9957        '''
9958         How many remaining requests out of the limit are still avaialable.
9959        '''
9960        self.reset_at = reset_at if reset_at is not None else None
9961        '''
9962         The time when remaining will be reset to limit.
9963        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9973    def to_dict(self):
9974        return {
9975            'bucket': self.bucket,
9976            'limit': self.limit,
9977            'remaining': self.remaining,
9978            'reset_at': self.reset_at,
9979        }
@classmethod
def from_dict(cls, d)
9981    @classmethod
9982    def from_dict(cls, d):
9983        return cls(
9984            bucket=d.get('bucket'),
9985            limit=d.get('limit'),
9986            remaining=d.get('remaining'),
9987            reset_at=d.get('reset_at'),
9988        )
class RawTCP:
 9991class RawTCP:
 9992    '''
 9993
 9994    '''
 9995    __slots__ = [
 9996        'bind_interface',
 9997        'egress_filter',
 9998        'healthy',
 9999        'hostname',
10000        'id',
10001        'name',
10002        'port',
10003        'port_override',
10004        'secret_store_id',
10005        'tags',
10006    ]
10007
10008    def __init__(
10009        self,
10010        bind_interface=None,
10011        egress_filter=None,
10012        healthy=None,
10013        hostname=None,
10014        id=None,
10015        name=None,
10016        port=None,
10017        port_override=None,
10018        secret_store_id=None,
10019        tags=None,
10020    ):
10021        self.bind_interface = bind_interface if bind_interface is not None else ''
10022        '''
10023         Bind interface
10024        '''
10025        self.egress_filter = egress_filter if egress_filter is not None else ''
10026        '''
10027         A filter applied to the routing logic to pin datasource to nodes.
10028        '''
10029        self.healthy = healthy if healthy is not None else False
10030        '''
10031         True if the datasource is reachable and the credentials are valid.
10032        '''
10033        self.hostname = hostname if hostname is not None else ''
10034        '''
10035
10036        '''
10037        self.id = id if id is not None else ''
10038        '''
10039         Unique identifier of the Resource.
10040        '''
10041        self.name = name if name is not None else ''
10042        '''
10043         Unique human-readable name of the Resource.
10044        '''
10045        self.port = port if port is not None else 0
10046        '''
10047
10048        '''
10049        self.port_override = port_override if port_override is not None else 0
10050        '''
10051
10052        '''
10053        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10054        '''
10055         ID of the secret store containing credentials for this resource, if any.
10056        '''
10057        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10058        '''
10059         Tags is a map of key, value pairs.
10060        '''
10061
10062    def __repr__(self):
10063        return '<sdm.RawTCP ' + \
10064            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10065            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10066            'healthy: ' + repr(self.healthy) + ' ' +\
10067            'hostname: ' + repr(self.hostname) + ' ' +\
10068            'id: ' + repr(self.id) + ' ' +\
10069            'name: ' + repr(self.name) + ' ' +\
10070            'port: ' + repr(self.port) + ' ' +\
10071            'port_override: ' + repr(self.port_override) + ' ' +\
10072            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10073            'tags: ' + repr(self.tags) + ' ' +\
10074            '>'
10075
10076    def to_dict(self):
10077        return {
10078            'bind_interface': self.bind_interface,
10079            'egress_filter': self.egress_filter,
10080            'healthy': self.healthy,
10081            'hostname': self.hostname,
10082            'id': self.id,
10083            'name': self.name,
10084            'port': self.port,
10085            'port_override': self.port_override,
10086            'secret_store_id': self.secret_store_id,
10087            'tags': self.tags,
10088        }
10089
10090    @classmethod
10091    def from_dict(cls, d):
10092        return cls(
10093            bind_interface=d.get('bind_interface'),
10094            egress_filter=d.get('egress_filter'),
10095            healthy=d.get('healthy'),
10096            hostname=d.get('hostname'),
10097            id=d.get('id'),
10098            name=d.get('name'),
10099            port=d.get('port'),
10100            port_override=d.get('port_override'),
10101            secret_store_id=d.get('secret_store_id'),
10102            tags=d.get('tags'),
10103        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
10008    def __init__(
10009        self,
10010        bind_interface=None,
10011        egress_filter=None,
10012        healthy=None,
10013        hostname=None,
10014        id=None,
10015        name=None,
10016        port=None,
10017        port_override=None,
10018        secret_store_id=None,
10019        tags=None,
10020    ):
10021        self.bind_interface = bind_interface if bind_interface is not None else ''
10022        '''
10023         Bind interface
10024        '''
10025        self.egress_filter = egress_filter if egress_filter is not None else ''
10026        '''
10027         A filter applied to the routing logic to pin datasource to nodes.
10028        '''
10029        self.healthy = healthy if healthy is not None else False
10030        '''
10031         True if the datasource is reachable and the credentials are valid.
10032        '''
10033        self.hostname = hostname if hostname is not None else ''
10034        '''
10035
10036        '''
10037        self.id = id if id is not None else ''
10038        '''
10039         Unique identifier of the Resource.
10040        '''
10041        self.name = name if name is not None else ''
10042        '''
10043         Unique human-readable name of the Resource.
10044        '''
10045        self.port = port if port is not None else 0
10046        '''
10047
10048        '''
10049        self.port_override = port_override if port_override is not None else 0
10050        '''
10051
10052        '''
10053        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10054        '''
10055         ID of the secret store containing credentials for this resource, if any.
10056        '''
10057        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10058        '''
10059         Tags is a map of key, value pairs.
10060        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10076    def to_dict(self):
10077        return {
10078            'bind_interface': self.bind_interface,
10079            'egress_filter': self.egress_filter,
10080            'healthy': self.healthy,
10081            'hostname': self.hostname,
10082            'id': self.id,
10083            'name': self.name,
10084            'port': self.port,
10085            'port_override': self.port_override,
10086            'secret_store_id': self.secret_store_id,
10087            'tags': self.tags,
10088        }
@classmethod
def from_dict(cls, d)
10090    @classmethod
10091    def from_dict(cls, d):
10092        return cls(
10093            bind_interface=d.get('bind_interface'),
10094            egress_filter=d.get('egress_filter'),
10095            healthy=d.get('healthy'),
10096            hostname=d.get('hostname'),
10097            id=d.get('id'),
10098            name=d.get('name'),
10099            port=d.get('port'),
10100            port_override=d.get('port_override'),
10101            secret_store_id=d.get('secret_store_id'),
10102            tags=d.get('tags'),
10103        )
class Redis:
10106class Redis:
10107    '''
10108
10109    '''
10110    __slots__ = [
10111        'bind_interface',
10112        'egress_filter',
10113        'healthy',
10114        'hostname',
10115        'id',
10116        'name',
10117        'password',
10118        'port',
10119        'port_override',
10120        'secret_store_id',
10121        'tags',
10122    ]
10123
10124    def __init__(
10125        self,
10126        bind_interface=None,
10127        egress_filter=None,
10128        healthy=None,
10129        hostname=None,
10130        id=None,
10131        name=None,
10132        password=None,
10133        port=None,
10134        port_override=None,
10135        secret_store_id=None,
10136        tags=None,
10137    ):
10138        self.bind_interface = bind_interface if bind_interface is not None else ''
10139        '''
10140         Bind interface
10141        '''
10142        self.egress_filter = egress_filter if egress_filter is not None else ''
10143        '''
10144         A filter applied to the routing logic to pin datasource to nodes.
10145        '''
10146        self.healthy = healthy if healthy is not None else False
10147        '''
10148         True if the datasource is reachable and the credentials are valid.
10149        '''
10150        self.hostname = hostname if hostname is not None else ''
10151        '''
10152
10153        '''
10154        self.id = id if id is not None else ''
10155        '''
10156         Unique identifier of the Resource.
10157        '''
10158        self.name = name if name is not None else ''
10159        '''
10160         Unique human-readable name of the Resource.
10161        '''
10162        self.password = password if password is not None else ''
10163        '''
10164
10165        '''
10166        self.port = port if port is not None else 0
10167        '''
10168
10169        '''
10170        self.port_override = port_override if port_override is not None else 0
10171        '''
10172
10173        '''
10174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10175        '''
10176         ID of the secret store containing credentials for this resource, if any.
10177        '''
10178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10179        '''
10180         Tags is a map of key, value pairs.
10181        '''
10182
10183    def __repr__(self):
10184        return '<sdm.Redis ' + \
10185            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10186            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10187            'healthy: ' + repr(self.healthy) + ' ' +\
10188            'hostname: ' + repr(self.hostname) + ' ' +\
10189            'id: ' + repr(self.id) + ' ' +\
10190            'name: ' + repr(self.name) + ' ' +\
10191            'password: ' + repr(self.password) + ' ' +\
10192            'port: ' + repr(self.port) + ' ' +\
10193            'port_override: ' + repr(self.port_override) + ' ' +\
10194            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10195            'tags: ' + repr(self.tags) + ' ' +\
10196            '>'
10197
10198    def to_dict(self):
10199        return {
10200            'bind_interface': self.bind_interface,
10201            'egress_filter': self.egress_filter,
10202            'healthy': self.healthy,
10203            'hostname': self.hostname,
10204            'id': self.id,
10205            'name': self.name,
10206            'password': self.password,
10207            'port': self.port,
10208            'port_override': self.port_override,
10209            'secret_store_id': self.secret_store_id,
10210            'tags': self.tags,
10211        }
10212
10213    @classmethod
10214    def from_dict(cls, d):
10215        return cls(
10216            bind_interface=d.get('bind_interface'),
10217            egress_filter=d.get('egress_filter'),
10218            healthy=d.get('healthy'),
10219            hostname=d.get('hostname'),
10220            id=d.get('id'),
10221            name=d.get('name'),
10222            password=d.get('password'),
10223            port=d.get('port'),
10224            port_override=d.get('port_override'),
10225            secret_store_id=d.get('secret_store_id'),
10226            tags=d.get('tags'),
10227        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
10124    def __init__(
10125        self,
10126        bind_interface=None,
10127        egress_filter=None,
10128        healthy=None,
10129        hostname=None,
10130        id=None,
10131        name=None,
10132        password=None,
10133        port=None,
10134        port_override=None,
10135        secret_store_id=None,
10136        tags=None,
10137    ):
10138        self.bind_interface = bind_interface if bind_interface is not None else ''
10139        '''
10140         Bind interface
10141        '''
10142        self.egress_filter = egress_filter if egress_filter is not None else ''
10143        '''
10144         A filter applied to the routing logic to pin datasource to nodes.
10145        '''
10146        self.healthy = healthy if healthy is not None else False
10147        '''
10148         True if the datasource is reachable and the credentials are valid.
10149        '''
10150        self.hostname = hostname if hostname is not None else ''
10151        '''
10152
10153        '''
10154        self.id = id if id is not None else ''
10155        '''
10156         Unique identifier of the Resource.
10157        '''
10158        self.name = name if name is not None else ''
10159        '''
10160         Unique human-readable name of the Resource.
10161        '''
10162        self.password = password if password is not None else ''
10163        '''
10164
10165        '''
10166        self.port = port if port is not None else 0
10167        '''
10168
10169        '''
10170        self.port_override = port_override if port_override is not None else 0
10171        '''
10172
10173        '''
10174        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10175        '''
10176         ID of the secret store containing credentials for this resource, if any.
10177        '''
10178        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10179        '''
10180         Tags is a map of key, value pairs.
10181        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10198    def to_dict(self):
10199        return {
10200            'bind_interface': self.bind_interface,
10201            'egress_filter': self.egress_filter,
10202            'healthy': self.healthy,
10203            'hostname': self.hostname,
10204            'id': self.id,
10205            'name': self.name,
10206            'password': self.password,
10207            'port': self.port,
10208            'port_override': self.port_override,
10209            'secret_store_id': self.secret_store_id,
10210            'tags': self.tags,
10211        }
@classmethod
def from_dict(cls, d)
10213    @classmethod
10214    def from_dict(cls, d):
10215        return cls(
10216            bind_interface=d.get('bind_interface'),
10217            egress_filter=d.get('egress_filter'),
10218            healthy=d.get('healthy'),
10219            hostname=d.get('hostname'),
10220            id=d.get('id'),
10221            name=d.get('name'),
10222            password=d.get('password'),
10223            port=d.get('port'),
10224            port_override=d.get('port_override'),
10225            secret_store_id=d.get('secret_store_id'),
10226            tags=d.get('tags'),
10227        )
class Redshift:
10230class Redshift:
10231    '''
10232
10233    '''
10234    __slots__ = [
10235        'bind_interface',
10236        'database',
10237        'egress_filter',
10238        'healthy',
10239        'hostname',
10240        'id',
10241        'name',
10242        'override_database',
10243        'password',
10244        'port',
10245        'port_override',
10246        'secret_store_id',
10247        'tags',
10248        'username',
10249    ]
10250
10251    def __init__(
10252        self,
10253        bind_interface=None,
10254        database=None,
10255        egress_filter=None,
10256        healthy=None,
10257        hostname=None,
10258        id=None,
10259        name=None,
10260        override_database=None,
10261        password=None,
10262        port=None,
10263        port_override=None,
10264        secret_store_id=None,
10265        tags=None,
10266        username=None,
10267    ):
10268        self.bind_interface = bind_interface if bind_interface is not None else ''
10269        '''
10270         Bind interface
10271        '''
10272        self.database = database if database is not None else ''
10273        '''
10274
10275        '''
10276        self.egress_filter = egress_filter if egress_filter is not None else ''
10277        '''
10278         A filter applied to the routing logic to pin datasource to nodes.
10279        '''
10280        self.healthy = healthy if healthy is not None else False
10281        '''
10282         True if the datasource is reachable and the credentials are valid.
10283        '''
10284        self.hostname = hostname if hostname is not None else ''
10285        '''
10286
10287        '''
10288        self.id = id if id is not None else ''
10289        '''
10290         Unique identifier of the Resource.
10291        '''
10292        self.name = name if name is not None else ''
10293        '''
10294         Unique human-readable name of the Resource.
10295        '''
10296        self.override_database = override_database if override_database is not None else False
10297        '''
10298
10299        '''
10300        self.password = password if password is not None else ''
10301        '''
10302
10303        '''
10304        self.port = port if port is not None else 0
10305        '''
10306
10307        '''
10308        self.port_override = port_override if port_override is not None else 0
10309        '''
10310
10311        '''
10312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10313        '''
10314         ID of the secret store containing credentials for this resource, if any.
10315        '''
10316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10317        '''
10318         Tags is a map of key, value pairs.
10319        '''
10320        self.username = username if username is not None else ''
10321        '''
10322
10323        '''
10324
10325    def __repr__(self):
10326        return '<sdm.Redshift ' + \
10327            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10328            'database: ' + repr(self.database) + ' ' +\
10329            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10330            'healthy: ' + repr(self.healthy) + ' ' +\
10331            'hostname: ' + repr(self.hostname) + ' ' +\
10332            'id: ' + repr(self.id) + ' ' +\
10333            'name: ' + repr(self.name) + ' ' +\
10334            'override_database: ' + repr(self.override_database) + ' ' +\
10335            'password: ' + repr(self.password) + ' ' +\
10336            'port: ' + repr(self.port) + ' ' +\
10337            'port_override: ' + repr(self.port_override) + ' ' +\
10338            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10339            'tags: ' + repr(self.tags) + ' ' +\
10340            'username: ' + repr(self.username) + ' ' +\
10341            '>'
10342
10343    def to_dict(self):
10344        return {
10345            'bind_interface': self.bind_interface,
10346            'database': self.database,
10347            'egress_filter': self.egress_filter,
10348            'healthy': self.healthy,
10349            'hostname': self.hostname,
10350            'id': self.id,
10351            'name': self.name,
10352            'override_database': self.override_database,
10353            'password': self.password,
10354            'port': self.port,
10355            'port_override': self.port_override,
10356            'secret_store_id': self.secret_store_id,
10357            'tags': self.tags,
10358            'username': self.username,
10359        }
10360
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            bind_interface=d.get('bind_interface'),
10365            database=d.get('database'),
10366            egress_filter=d.get('egress_filter'),
10367            healthy=d.get('healthy'),
10368            hostname=d.get('hostname'),
10369            id=d.get('id'),
10370            name=d.get('name'),
10371            override_database=d.get('override_database'),
10372            password=d.get('password'),
10373            port=d.get('port'),
10374            port_override=d.get('port_override'),
10375            secret_store_id=d.get('secret_store_id'),
10376            tags=d.get('tags'),
10377            username=d.get('username'),
10378        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
10251    def __init__(
10252        self,
10253        bind_interface=None,
10254        database=None,
10255        egress_filter=None,
10256        healthy=None,
10257        hostname=None,
10258        id=None,
10259        name=None,
10260        override_database=None,
10261        password=None,
10262        port=None,
10263        port_override=None,
10264        secret_store_id=None,
10265        tags=None,
10266        username=None,
10267    ):
10268        self.bind_interface = bind_interface if bind_interface is not None else ''
10269        '''
10270         Bind interface
10271        '''
10272        self.database = database if database is not None else ''
10273        '''
10274
10275        '''
10276        self.egress_filter = egress_filter if egress_filter is not None else ''
10277        '''
10278         A filter applied to the routing logic to pin datasource to nodes.
10279        '''
10280        self.healthy = healthy if healthy is not None else False
10281        '''
10282         True if the datasource is reachable and the credentials are valid.
10283        '''
10284        self.hostname = hostname if hostname is not None else ''
10285        '''
10286
10287        '''
10288        self.id = id if id is not None else ''
10289        '''
10290         Unique identifier of the Resource.
10291        '''
10292        self.name = name if name is not None else ''
10293        '''
10294         Unique human-readable name of the Resource.
10295        '''
10296        self.override_database = override_database if override_database is not None else False
10297        '''
10298
10299        '''
10300        self.password = password if password is not None else ''
10301        '''
10302
10303        '''
10304        self.port = port if port is not None else 0
10305        '''
10306
10307        '''
10308        self.port_override = port_override if port_override is not None else 0
10309        '''
10310
10311        '''
10312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10313        '''
10314         ID of the secret store containing credentials for this resource, if any.
10315        '''
10316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10317        '''
10318         Tags is a map of key, value pairs.
10319        '''
10320        self.username = username if username is not None else ''
10321        '''
10322
10323        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10343    def to_dict(self):
10344        return {
10345            'bind_interface': self.bind_interface,
10346            'database': self.database,
10347            'egress_filter': self.egress_filter,
10348            'healthy': self.healthy,
10349            'hostname': self.hostname,
10350            'id': self.id,
10351            'name': self.name,
10352            'override_database': self.override_database,
10353            'password': self.password,
10354            'port': self.port,
10355            'port_override': self.port_override,
10356            'secret_store_id': self.secret_store_id,
10357            'tags': self.tags,
10358            'username': self.username,
10359        }
@classmethod
def from_dict(cls, d)
10361    @classmethod
10362    def from_dict(cls, d):
10363        return cls(
10364            bind_interface=d.get('bind_interface'),
10365            database=d.get('database'),
10366            egress_filter=d.get('egress_filter'),
10367            healthy=d.get('healthy'),
10368            hostname=d.get('hostname'),
10369            id=d.get('id'),
10370            name=d.get('name'),
10371            override_database=d.get('override_database'),
10372            password=d.get('password'),
10373            port=d.get('port'),
10374            port_override=d.get('port_override'),
10375            secret_store_id=d.get('secret_store_id'),
10376            tags=d.get('tags'),
10377            username=d.get('username'),
10378        )
class Relay:
10381class Relay:
10382    '''
10383     Relay represents a StrongDM CLI installation running in relay mode.
10384    '''
10385    __slots__ = [
10386        'gateway_filter',
10387        'id',
10388        'name',
10389        'state',
10390        'tags',
10391    ]
10392
10393    def __init__(
10394        self,
10395        gateway_filter=None,
10396        id=None,
10397        name=None,
10398        state=None,
10399        tags=None,
10400    ):
10401        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10402        '''
10403         GatewayFilter can be used to restrict the peering between relays and
10404         gateways.
10405        '''
10406        self.id = id if id is not None else ''
10407        '''
10408         Unique identifier of the Relay.
10409        '''
10410        self.name = name if name is not None else ''
10411        '''
10412         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10413        '''
10414        self.state = state if state is not None else ''
10415        '''
10416         The current state of the relay. One of: "new", "verifying_restart",
10417         "awaiting_restart", "restarting", "started", "stopped", "dead",
10418         "unknown".
10419        '''
10420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10421        '''
10422         Tags is a map of key, value pairs.
10423        '''
10424
10425    def __repr__(self):
10426        return '<sdm.Relay ' + \
10427            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10428            'id: ' + repr(self.id) + ' ' +\
10429            'name: ' + repr(self.name) + ' ' +\
10430            'state: ' + repr(self.state) + ' ' +\
10431            'tags: ' + repr(self.tags) + ' ' +\
10432            '>'
10433
10434    def to_dict(self):
10435        return {
10436            'gateway_filter': self.gateway_filter,
10437            'id': self.id,
10438            'name': self.name,
10439            'state': self.state,
10440            'tags': self.tags,
10441        }
10442
10443    @classmethod
10444    def from_dict(cls, d):
10445        return cls(
10446            gateway_filter=d.get('gateway_filter'),
10447            id=d.get('id'),
10448            name=d.get('name'),
10449            state=d.get('state'),
10450            tags=d.get('tags'),
10451        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
10393    def __init__(
10394        self,
10395        gateway_filter=None,
10396        id=None,
10397        name=None,
10398        state=None,
10399        tags=None,
10400    ):
10401        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10402        '''
10403         GatewayFilter can be used to restrict the peering between relays and
10404         gateways.
10405        '''
10406        self.id = id if id is not None else ''
10407        '''
10408         Unique identifier of the Relay.
10409        '''
10410        self.name = name if name is not None else ''
10411        '''
10412         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10413        '''
10414        self.state = state if state is not None else ''
10415        '''
10416         The current state of the relay. One of: "new", "verifying_restart",
10417         "awaiting_restart", "restarting", "started", "stopped", "dead",
10418         "unknown".
10419        '''
10420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10421        '''
10422         Tags is a map of key, value pairs.
10423        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
10434    def to_dict(self):
10435        return {
10436            'gateway_filter': self.gateway_filter,
10437            'id': self.id,
10438            'name': self.name,
10439            'state': self.state,
10440            'tags': self.tags,
10441        }
@classmethod
def from_dict(cls, d)
10443    @classmethod
10444    def from_dict(cls, d):
10445        return cls(
10446            gateway_filter=d.get('gateway_filter'),
10447            id=d.get('id'),
10448            name=d.get('name'),
10449            state=d.get('state'),
10450            tags=d.get('tags'),
10451        )
class RemoteIdentity:
10454class RemoteIdentity:
10455    '''
10456     RemoteIdentities define the username to be used for a specific account
10457     when connecting to a remote resource using that group.
10458    '''
10459    __slots__ = [
10460        'account_id',
10461        'id',
10462        'remote_identity_group_id',
10463        'username',
10464    ]
10465
10466    def __init__(
10467        self,
10468        account_id=None,
10469        id=None,
10470        remote_identity_group_id=None,
10471        username=None,
10472    ):
10473        self.account_id = account_id if account_id is not None else ''
10474        '''
10475         The account for this remote identity.
10476        '''
10477        self.id = id if id is not None else ''
10478        '''
10479         Unique identifier of the RemoteIdentity.
10480        '''
10481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10482        '''
10483         The remote identity group.
10484        '''
10485        self.username = username if username is not None else ''
10486        '''
10487         The username to be used as the remote identity for this account.
10488        '''
10489
10490    def __repr__(self):
10491        return '<sdm.RemoteIdentity ' + \
10492            'account_id: ' + repr(self.account_id) + ' ' +\
10493            'id: ' + repr(self.id) + ' ' +\
10494            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10495            'username: ' + repr(self.username) + ' ' +\
10496            '>'
10497
10498    def to_dict(self):
10499        return {
10500            'account_id': self.account_id,
10501            'id': self.id,
10502            'remote_identity_group_id': self.remote_identity_group_id,
10503            'username': self.username,
10504        }
10505
10506    @classmethod
10507    def from_dict(cls, d):
10508        return cls(
10509            account_id=d.get('account_id'),
10510            id=d.get('id'),
10511            remote_identity_group_id=d.get('remote_identity_group_id'),
10512            username=d.get('username'),
10513        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
10466    def __init__(
10467        self,
10468        account_id=None,
10469        id=None,
10470        remote_identity_group_id=None,
10471        username=None,
10472    ):
10473        self.account_id = account_id if account_id is not None else ''
10474        '''
10475         The account for this remote identity.
10476        '''
10477        self.id = id if id is not None else ''
10478        '''
10479         Unique identifier of the RemoteIdentity.
10480        '''
10481        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10482        '''
10483         The remote identity group.
10484        '''
10485        self.username = username if username is not None else ''
10486        '''
10487         The username to be used as the remote identity for this account.
10488        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
10498    def to_dict(self):
10499        return {
10500            'account_id': self.account_id,
10501            'id': self.id,
10502            'remote_identity_group_id': self.remote_identity_group_id,
10503            'username': self.username,
10504        }
@classmethod
def from_dict(cls, d)
10506    @classmethod
10507    def from_dict(cls, d):
10508        return cls(
10509            account_id=d.get('account_id'),
10510            id=d.get('id'),
10511            remote_identity_group_id=d.get('remote_identity_group_id'),
10512            username=d.get('username'),
10513        )
class RemoteIdentityCreateResponse:
10516class RemoteIdentityCreateResponse:
10517    '''
10518     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10519    '''
10520    __slots__ = [
10521        'meta',
10522        'rate_limit',
10523        'remote_identity',
10524    ]
10525
10526    def __init__(
10527        self,
10528        meta=None,
10529        rate_limit=None,
10530        remote_identity=None,
10531    ):
10532        self.meta = meta if meta is not None else None
10533        '''
10534         Reserved for future use.
10535        '''
10536        self.rate_limit = rate_limit if rate_limit is not None else None
10537        '''
10538         Rate limit information.
10539        '''
10540        self.remote_identity = remote_identity if remote_identity is not None else None
10541        '''
10542         The created RemoteIdentity.
10543        '''
10544
10545    def __repr__(self):
10546        return '<sdm.RemoteIdentityCreateResponse ' + \
10547            'meta: ' + repr(self.meta) + ' ' +\
10548            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10549            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10550            '>'
10551
10552    def to_dict(self):
10553        return {
10554            'meta': self.meta,
10555            'rate_limit': self.rate_limit,
10556            'remote_identity': self.remote_identity,
10557        }
10558
10559    @classmethod
10560    def from_dict(cls, d):
10561        return cls(
10562            meta=d.get('meta'),
10563            rate_limit=d.get('rate_limit'),
10564            remote_identity=d.get('remote_identity'),
10565        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
10526    def __init__(
10527        self,
10528        meta=None,
10529        rate_limit=None,
10530        remote_identity=None,
10531    ):
10532        self.meta = meta if meta is not None else None
10533        '''
10534         Reserved for future use.
10535        '''
10536        self.rate_limit = rate_limit if rate_limit is not None else None
10537        '''
10538         Rate limit information.
10539        '''
10540        self.remote_identity = remote_identity if remote_identity is not None else None
10541        '''
10542         The created RemoteIdentity.
10543        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
10552    def to_dict(self):
10553        return {
10554            'meta': self.meta,
10555            'rate_limit': self.rate_limit,
10556            'remote_identity': self.remote_identity,
10557        }
@classmethod
def from_dict(cls, d)
10559    @classmethod
10560    def from_dict(cls, d):
10561        return cls(
10562            meta=d.get('meta'),
10563            rate_limit=d.get('rate_limit'),
10564            remote_identity=d.get('remote_identity'),
10565        )
class RemoteIdentityDeleteResponse:
10568class RemoteIdentityDeleteResponse:
10569    '''
10570     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10571    '''
10572    __slots__ = [
10573        'meta',
10574        'rate_limit',
10575    ]
10576
10577    def __init__(
10578        self,
10579        meta=None,
10580        rate_limit=None,
10581    ):
10582        self.meta = meta if meta is not None else None
10583        '''
10584         Reserved for future use.
10585        '''
10586        self.rate_limit = rate_limit if rate_limit is not None else None
10587        '''
10588         Rate limit information.
10589        '''
10590
10591    def __repr__(self):
10592        return '<sdm.RemoteIdentityDeleteResponse ' + \
10593            'meta: ' + repr(self.meta) + ' ' +\
10594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10595            '>'
10596
10597    def to_dict(self):
10598        return {
10599            'meta': self.meta,
10600            'rate_limit': self.rate_limit,
10601        }
10602
10603    @classmethod
10604    def from_dict(cls, d):
10605        return cls(
10606            meta=d.get('meta'),
10607            rate_limit=d.get('rate_limit'),
10608        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
10577    def __init__(
10578        self,
10579        meta=None,
10580        rate_limit=None,
10581    ):
10582        self.meta = meta if meta is not None else None
10583        '''
10584         Reserved for future use.
10585        '''
10586        self.rate_limit = rate_limit if rate_limit is not None else None
10587        '''
10588         Rate limit information.
10589        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10597    def to_dict(self):
10598        return {
10599            'meta': self.meta,
10600            'rate_limit': self.rate_limit,
10601        }
@classmethod
def from_dict(cls, d)
10603    @classmethod
10604    def from_dict(cls, d):
10605        return cls(
10606            meta=d.get('meta'),
10607            rate_limit=d.get('rate_limit'),
10608        )
class RemoteIdentityGetResponse:
10611class RemoteIdentityGetResponse:
10612    '''
10613     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10614    '''
10615    __slots__ = [
10616        'meta',
10617        'rate_limit',
10618        'remote_identity',
10619    ]
10620
10621    def __init__(
10622        self,
10623        meta=None,
10624        rate_limit=None,
10625        remote_identity=None,
10626    ):
10627        self.meta = meta if meta is not None else None
10628        '''
10629         Reserved for future use.
10630        '''
10631        self.rate_limit = rate_limit if rate_limit is not None else None
10632        '''
10633         Rate limit information.
10634        '''
10635        self.remote_identity = remote_identity if remote_identity is not None else None
10636        '''
10637         The requested RemoteIdentity.
10638        '''
10639
10640    def __repr__(self):
10641        return '<sdm.RemoteIdentityGetResponse ' + \
10642            'meta: ' + repr(self.meta) + ' ' +\
10643            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10644            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10645            '>'
10646
10647    def to_dict(self):
10648        return {
10649            'meta': self.meta,
10650            'rate_limit': self.rate_limit,
10651            'remote_identity': self.remote_identity,
10652        }
10653
10654    @classmethod
10655    def from_dict(cls, d):
10656        return cls(
10657            meta=d.get('meta'),
10658            rate_limit=d.get('rate_limit'),
10659            remote_identity=d.get('remote_identity'),
10660        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
10621    def __init__(
10622        self,
10623        meta=None,
10624        rate_limit=None,
10625        remote_identity=None,
10626    ):
10627        self.meta = meta if meta is not None else None
10628        '''
10629         Reserved for future use.
10630        '''
10631        self.rate_limit = rate_limit if rate_limit is not None else None
10632        '''
10633         Rate limit information.
10634        '''
10635        self.remote_identity = remote_identity if remote_identity is not None else None
10636        '''
10637         The requested RemoteIdentity.
10638        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10647    def to_dict(self):
10648        return {
10649            'meta': self.meta,
10650            'rate_limit': self.rate_limit,
10651            'remote_identity': self.remote_identity,
10652        }
@classmethod
def from_dict(cls, d)
10654    @classmethod
10655    def from_dict(cls, d):
10656        return cls(
10657            meta=d.get('meta'),
10658            rate_limit=d.get('rate_limit'),
10659            remote_identity=d.get('remote_identity'),
10660        )
class RemoteIdentityGroup:
10663class RemoteIdentityGroup:
10664    '''
10665     A RemoteIdentityGroup defines a group of remote identities.
10666    '''
10667    __slots__ = [
10668        'id',
10669        'name',
10670    ]
10671
10672    def __init__(
10673        self,
10674        id=None,
10675        name=None,
10676    ):
10677        self.id = id if id is not None else ''
10678        '''
10679         Unique identifier of the RemoteIdentityGroup.
10680        '''
10681        self.name = name if name is not None else ''
10682        '''
10683         Unique human-readable name of the RemoteIdentityGroup.
10684        '''
10685
10686    def __repr__(self):
10687        return '<sdm.RemoteIdentityGroup ' + \
10688            'id: ' + repr(self.id) + ' ' +\
10689            'name: ' + repr(self.name) + ' ' +\
10690            '>'
10691
10692    def to_dict(self):
10693        return {
10694            'id': self.id,
10695            'name': self.name,
10696        }
10697
10698    @classmethod
10699    def from_dict(cls, d):
10700        return cls(
10701            id=d.get('id'),
10702            name=d.get('name'),
10703        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10672    def __init__(
10673        self,
10674        id=None,
10675        name=None,
10676    ):
10677        self.id = id if id is not None else ''
10678        '''
10679         Unique identifier of the RemoteIdentityGroup.
10680        '''
10681        self.name = name if name is not None else ''
10682        '''
10683         Unique human-readable name of the RemoteIdentityGroup.
10684        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10692    def to_dict(self):
10693        return {
10694            'id': self.id,
10695            'name': self.name,
10696        }
@classmethod
def from_dict(cls, d)
10698    @classmethod
10699    def from_dict(cls, d):
10700        return cls(
10701            id=d.get('id'),
10702            name=d.get('name'),
10703        )
class RemoteIdentityGroupGetResponse:
10706class RemoteIdentityGroupGetResponse:
10707    '''
10708     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10709    '''
10710    __slots__ = [
10711        'meta',
10712        'rate_limit',
10713        'remote_identity_group',
10714    ]
10715
10716    def __init__(
10717        self,
10718        meta=None,
10719        rate_limit=None,
10720        remote_identity_group=None,
10721    ):
10722        self.meta = meta if meta is not None else None
10723        '''
10724         Reserved for future use.
10725        '''
10726        self.rate_limit = rate_limit if rate_limit is not None else None
10727        '''
10728         Rate limit information.
10729        '''
10730        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10731        '''
10732         The requested RemoteIdentityGroup.
10733        '''
10734
10735    def __repr__(self):
10736        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10737            'meta: ' + repr(self.meta) + ' ' +\
10738            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10739            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10740            '>'
10741
10742    def to_dict(self):
10743        return {
10744            'meta': self.meta,
10745            'rate_limit': self.rate_limit,
10746            'remote_identity_group': self.remote_identity_group,
10747        }
10748
10749    @classmethod
10750    def from_dict(cls, d):
10751        return cls(
10752            meta=d.get('meta'),
10753            rate_limit=d.get('rate_limit'),
10754            remote_identity_group=d.get('remote_identity_group'),
10755        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10716    def __init__(
10717        self,
10718        meta=None,
10719        rate_limit=None,
10720        remote_identity_group=None,
10721    ):
10722        self.meta = meta if meta is not None else None
10723        '''
10724         Reserved for future use.
10725        '''
10726        self.rate_limit = rate_limit if rate_limit is not None else None
10727        '''
10728         Rate limit information.
10729        '''
10730        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10731        '''
10732         The requested RemoteIdentityGroup.
10733        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10742    def to_dict(self):
10743        return {
10744            'meta': self.meta,
10745            'rate_limit': self.rate_limit,
10746            'remote_identity_group': self.remote_identity_group,
10747        }
@classmethod
def from_dict(cls, d)
10749    @classmethod
10750    def from_dict(cls, d):
10751        return cls(
10752            meta=d.get('meta'),
10753            rate_limit=d.get('rate_limit'),
10754            remote_identity_group=d.get('remote_identity_group'),
10755        )
class RemoteIdentityUpdateResponse:
10758class RemoteIdentityUpdateResponse:
10759    '''
10760     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10761     a RemoteIdentityUpdateRequest.
10762    '''
10763    __slots__ = [
10764        'meta',
10765        'rate_limit',
10766        'remote_identity',
10767    ]
10768
10769    def __init__(
10770        self,
10771        meta=None,
10772        rate_limit=None,
10773        remote_identity=None,
10774    ):
10775        self.meta = meta if meta is not None else None
10776        '''
10777         Reserved for future use.
10778        '''
10779        self.rate_limit = rate_limit if rate_limit is not None else None
10780        '''
10781         Rate limit information.
10782        '''
10783        self.remote_identity = remote_identity if remote_identity is not None else None
10784        '''
10785         The updated RemoteIdentity.
10786        '''
10787
10788    def __repr__(self):
10789        return '<sdm.RemoteIdentityUpdateResponse ' + \
10790            'meta: ' + repr(self.meta) + ' ' +\
10791            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10792            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10793            '>'
10794
10795    def to_dict(self):
10796        return {
10797            'meta': self.meta,
10798            'rate_limit': self.rate_limit,
10799            'remote_identity': self.remote_identity,
10800        }
10801
10802    @classmethod
10803    def from_dict(cls, d):
10804        return cls(
10805            meta=d.get('meta'),
10806            rate_limit=d.get('rate_limit'),
10807            remote_identity=d.get('remote_identity'),
10808        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10769    def __init__(
10770        self,
10771        meta=None,
10772        rate_limit=None,
10773        remote_identity=None,
10774    ):
10775        self.meta = meta if meta is not None else None
10776        '''
10777         Reserved for future use.
10778        '''
10779        self.rate_limit = rate_limit if rate_limit is not None else None
10780        '''
10781         Rate limit information.
10782        '''
10783        self.remote_identity = remote_identity if remote_identity is not None else None
10784        '''
10785         The updated RemoteIdentity.
10786        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10795    def to_dict(self):
10796        return {
10797            'meta': self.meta,
10798            'rate_limit': self.rate_limit,
10799            'remote_identity': self.remote_identity,
10800        }
@classmethod
def from_dict(cls, d)
10802    @classmethod
10803    def from_dict(cls, d):
10804        return cls(
10805            meta=d.get('meta'),
10806            rate_limit=d.get('rate_limit'),
10807            remote_identity=d.get('remote_identity'),
10808        )
class ResourceCreateResponse:
10811class ResourceCreateResponse:
10812    '''
10813     ResourceCreateResponse reports how the Resources were created in the system.
10814    '''
10815    __slots__ = [
10816        'meta',
10817        'rate_limit',
10818        'resource',
10819    ]
10820
10821    def __init__(
10822        self,
10823        meta=None,
10824        rate_limit=None,
10825        resource=None,
10826    ):
10827        self.meta = meta if meta is not None else None
10828        '''
10829         Reserved for future use.
10830        '''
10831        self.rate_limit = rate_limit if rate_limit is not None else None
10832        '''
10833         Rate limit information.
10834        '''
10835        self.resource = resource if resource is not None else None
10836        '''
10837         The created Resource.
10838        '''
10839
10840    def __repr__(self):
10841        return '<sdm.ResourceCreateResponse ' + \
10842            'meta: ' + repr(self.meta) + ' ' +\
10843            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10844            'resource: ' + repr(self.resource) + ' ' +\
10845            '>'
10846
10847    def to_dict(self):
10848        return {
10849            'meta': self.meta,
10850            'rate_limit': self.rate_limit,
10851            'resource': self.resource,
10852        }
10853
10854    @classmethod
10855    def from_dict(cls, d):
10856        return cls(
10857            meta=d.get('meta'),
10858            rate_limit=d.get('rate_limit'),
10859            resource=d.get('resource'),
10860        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10821    def __init__(
10822        self,
10823        meta=None,
10824        rate_limit=None,
10825        resource=None,
10826    ):
10827        self.meta = meta if meta is not None else None
10828        '''
10829         Reserved for future use.
10830        '''
10831        self.rate_limit = rate_limit if rate_limit is not None else None
10832        '''
10833         Rate limit information.
10834        '''
10835        self.resource = resource if resource is not None else None
10836        '''
10837         The created Resource.
10838        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10847    def to_dict(self):
10848        return {
10849            'meta': self.meta,
10850            'rate_limit': self.rate_limit,
10851            'resource': self.resource,
10852        }
@classmethod
def from_dict(cls, d)
10854    @classmethod
10855    def from_dict(cls, d):
10856        return cls(
10857            meta=d.get('meta'),
10858            rate_limit=d.get('rate_limit'),
10859            resource=d.get('resource'),
10860        )
class ResourceDeleteResponse:
10863class ResourceDeleteResponse:
10864    '''
10865     ResourceDeleteResponse returns information about a Resource that was deleted.
10866    '''
10867    __slots__ = [
10868        'meta',
10869        'rate_limit',
10870    ]
10871
10872    def __init__(
10873        self,
10874        meta=None,
10875        rate_limit=None,
10876    ):
10877        self.meta = meta if meta is not None else None
10878        '''
10879         Reserved for future use.
10880        '''
10881        self.rate_limit = rate_limit if rate_limit is not None else None
10882        '''
10883         Rate limit information.
10884        '''
10885
10886    def __repr__(self):
10887        return '<sdm.ResourceDeleteResponse ' + \
10888            'meta: ' + repr(self.meta) + ' ' +\
10889            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10890            '>'
10891
10892    def to_dict(self):
10893        return {
10894            'meta': self.meta,
10895            'rate_limit': self.rate_limit,
10896        }
10897
10898    @classmethod
10899    def from_dict(cls, d):
10900        return cls(
10901            meta=d.get('meta'),
10902            rate_limit=d.get('rate_limit'),
10903        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10872    def __init__(
10873        self,
10874        meta=None,
10875        rate_limit=None,
10876    ):
10877        self.meta = meta if meta is not None else None
10878        '''
10879         Reserved for future use.
10880        '''
10881        self.rate_limit = rate_limit if rate_limit is not None else None
10882        '''
10883         Rate limit information.
10884        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10892    def to_dict(self):
10893        return {
10894            'meta': self.meta,
10895            'rate_limit': self.rate_limit,
10896        }
@classmethod
def from_dict(cls, d)
10898    @classmethod
10899    def from_dict(cls, d):
10900        return cls(
10901            meta=d.get('meta'),
10902            rate_limit=d.get('rate_limit'),
10903        )
class ResourceGetResponse:
10906class ResourceGetResponse:
10907    '''
10908     ResourceGetResponse returns a requested Resource.
10909    '''
10910    __slots__ = [
10911        'meta',
10912        'rate_limit',
10913        'resource',
10914    ]
10915
10916    def __init__(
10917        self,
10918        meta=None,
10919        rate_limit=None,
10920        resource=None,
10921    ):
10922        self.meta = meta if meta is not None else None
10923        '''
10924         Reserved for future use.
10925        '''
10926        self.rate_limit = rate_limit if rate_limit is not None else None
10927        '''
10928         Rate limit information.
10929        '''
10930        self.resource = resource if resource is not None else None
10931        '''
10932         The requested Resource.
10933        '''
10934
10935    def __repr__(self):
10936        return '<sdm.ResourceGetResponse ' + \
10937            'meta: ' + repr(self.meta) + ' ' +\
10938            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10939            'resource: ' + repr(self.resource) + ' ' +\
10940            '>'
10941
10942    def to_dict(self):
10943        return {
10944            'meta': self.meta,
10945            'rate_limit': self.rate_limit,
10946            'resource': self.resource,
10947        }
10948
10949    @classmethod
10950    def from_dict(cls, d):
10951        return cls(
10952            meta=d.get('meta'),
10953            rate_limit=d.get('rate_limit'),
10954            resource=d.get('resource'),
10955        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10916    def __init__(
10917        self,
10918        meta=None,
10919        rate_limit=None,
10920        resource=None,
10921    ):
10922        self.meta = meta if meta is not None else None
10923        '''
10924         Reserved for future use.
10925        '''
10926        self.rate_limit = rate_limit if rate_limit is not None else None
10927        '''
10928         Rate limit information.
10929        '''
10930        self.resource = resource if resource is not None else None
10931        '''
10932         The requested Resource.
10933        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10942    def to_dict(self):
10943        return {
10944            'meta': self.meta,
10945            'rate_limit': self.rate_limit,
10946            'resource': self.resource,
10947        }
@classmethod
def from_dict(cls, d)
10949    @classmethod
10950    def from_dict(cls, d):
10951        return cls(
10952            meta=d.get('meta'),
10953            rate_limit=d.get('rate_limit'),
10954            resource=d.get('resource'),
10955        )
class ResourceUpdateResponse:
10958class ResourceUpdateResponse:
10959    '''
10960     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10961     a ResourceUpdateRequest.
10962    '''
10963    __slots__ = [
10964        'meta',
10965        'rate_limit',
10966        'resource',
10967    ]
10968
10969    def __init__(
10970        self,
10971        meta=None,
10972        rate_limit=None,
10973        resource=None,
10974    ):
10975        self.meta = meta if meta is not None else None
10976        '''
10977         Reserved for future use.
10978        '''
10979        self.rate_limit = rate_limit if rate_limit is not None else None
10980        '''
10981         Rate limit information.
10982        '''
10983        self.resource = resource if resource is not None else None
10984        '''
10985         The updated Resource.
10986        '''
10987
10988    def __repr__(self):
10989        return '<sdm.ResourceUpdateResponse ' + \
10990            'meta: ' + repr(self.meta) + ' ' +\
10991            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10992            'resource: ' + repr(self.resource) + ' ' +\
10993            '>'
10994
10995    def to_dict(self):
10996        return {
10997            'meta': self.meta,
10998            'rate_limit': self.rate_limit,
10999            'resource': self.resource,
11000        }
11001
11002    @classmethod
11003    def from_dict(cls, d):
11004        return cls(
11005            meta=d.get('meta'),
11006            rate_limit=d.get('rate_limit'),
11007            resource=d.get('resource'),
11008        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10969    def __init__(
10970        self,
10971        meta=None,
10972        rate_limit=None,
10973        resource=None,
10974    ):
10975        self.meta = meta if meta is not None else None
10976        '''
10977         Reserved for future use.
10978        '''
10979        self.rate_limit = rate_limit if rate_limit is not None else None
10980        '''
10981         Rate limit information.
10982        '''
10983        self.resource = resource if resource is not None else None
10984        '''
10985         The updated Resource.
10986        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10995    def to_dict(self):
10996        return {
10997            'meta': self.meta,
10998            'rate_limit': self.rate_limit,
10999            'resource': self.resource,
11000        }
@classmethod
def from_dict(cls, d)
11002    @classmethod
11003    def from_dict(cls, d):
11004        return cls(
11005            meta=d.get('meta'),
11006            rate_limit=d.get('rate_limit'),
11007            resource=d.get('resource'),
11008        )
class Role:
11011class Role:
11012    '''
11013     A Role has a list of access rules which determine which Resources the members
11014     of the Role have access to. An Account can be a member of multiple Roles via
11015     AccountAttachments.
11016    '''
11017    __slots__ = [
11018        'access_rules',
11019        'composite',
11020        'id',
11021        'name',
11022        'tags',
11023    ]
11024
11025    def __init__(
11026        self,
11027        access_rules=None,
11028        composite=None,
11029        id=None,
11030        name=None,
11031        tags=None,
11032    ):
11033        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11034        )
11035        '''
11036         AccessRules is a list of access rules defining the resources this Role has access to.
11037        '''
11038        self.composite = composite if composite is not None else False
11039        '''
11040         Composite is true if the Role is a composite role.
11041         
11042         Deprecated: composite roles are deprecated, use multi-role via
11043         AccountAttachments instead.
11044        '''
11045        self.id = id if id is not None else ''
11046        '''
11047         Unique identifier of the Role.
11048        '''
11049        self.name = name if name is not None else ''
11050        '''
11051         Unique human-readable name of the Role.
11052        '''
11053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11054        '''
11055         Tags is a map of key, value pairs.
11056        '''
11057
11058    def __repr__(self):
11059        return '<sdm.Role ' + \
11060            'access_rules: ' + repr(self.access_rules) + ' ' +\
11061            'composite: ' + repr(self.composite) + ' ' +\
11062            'id: ' + repr(self.id) + ' ' +\
11063            'name: ' + repr(self.name) + ' ' +\
11064            'tags: ' + repr(self.tags) + ' ' +\
11065            '>'
11066
11067    def to_dict(self):
11068        return {
11069            'access_rules': self.access_rules,
11070            'composite': self.composite,
11071            'id': self.id,
11072            'name': self.name,
11073            'tags': self.tags,
11074        }
11075
11076    @classmethod
11077    def from_dict(cls, d):
11078        return cls(
11079            access_rules=d.get('access_rules'),
11080            composite=d.get('composite'),
11081            id=d.get('id'),
11082            name=d.get('name'),
11083            tags=d.get('tags'),
11084        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, composite=None, id=None, name=None, tags=None)
11025    def __init__(
11026        self,
11027        access_rules=None,
11028        composite=None,
11029        id=None,
11030        name=None,
11031        tags=None,
11032    ):
11033        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
11034        )
11035        '''
11036         AccessRules is a list of access rules defining the resources this Role has access to.
11037        '''
11038        self.composite = composite if composite is not None else False
11039        '''
11040         Composite is true if the Role is a composite role.
11041         
11042         Deprecated: composite roles are deprecated, use multi-role via
11043         AccountAttachments instead.
11044        '''
11045        self.id = id if id is not None else ''
11046        '''
11047         Unique identifier of the Role.
11048        '''
11049        self.name = name if name is not None else ''
11050        '''
11051         Unique human-readable name of the Role.
11052        '''
11053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11054        '''
11055         Tags is a map of key, value pairs.
11056        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

composite

Composite is true if the Role is a composite role.

Deprecated: composite roles are deprecated, use multi-role via AccountAttachments instead.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11067    def to_dict(self):
11068        return {
11069            'access_rules': self.access_rules,
11070            'composite': self.composite,
11071            'id': self.id,
11072            'name': self.name,
11073            'tags': self.tags,
11074        }
@classmethod
def from_dict(cls, d)
11076    @classmethod
11077    def from_dict(cls, d):
11078        return cls(
11079            access_rules=d.get('access_rules'),
11080            composite=d.get('composite'),
11081            id=d.get('id'),
11082            name=d.get('name'),
11083            tags=d.get('tags'),
11084        )
class RoleAttachment:
11087class RoleAttachment:
11088    '''
11089     A RoleAttachment assigns a role to a composite role.
11090     
11091     Deprecated: use multi-role via AccountAttachments instead.
11092    '''
11093    __slots__ = [
11094        'attached_role_id',
11095        'composite_role_id',
11096        'id',
11097    ]
11098
11099    def __init__(
11100        self,
11101        attached_role_id=None,
11102        composite_role_id=None,
11103        id=None,
11104    ):
11105        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11106        '''
11107         The id of the attached role of this RoleAttachment.
11108        '''
11109        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11110        '''
11111         The id of the composite role of this RoleAttachment.
11112        '''
11113        self.id = id if id is not None else ''
11114        '''
11115         Unique identifier of the RoleAttachment.
11116        '''
11117
11118    def __repr__(self):
11119        return '<sdm.RoleAttachment ' + \
11120            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
11121            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
11122            'id: ' + repr(self.id) + ' ' +\
11123            '>'
11124
11125    def to_dict(self):
11126        return {
11127            'attached_role_id': self.attached_role_id,
11128            'composite_role_id': self.composite_role_id,
11129            'id': self.id,
11130        }
11131
11132    @classmethod
11133    def from_dict(cls, d):
11134        return cls(
11135            attached_role_id=d.get('attached_role_id'),
11136            composite_role_id=d.get('composite_role_id'),
11137            id=d.get('id'),
11138        )

A RoleAttachment assigns a role to a composite role.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachment(attached_role_id=None, composite_role_id=None, id=None)
11099    def __init__(
11100        self,
11101        attached_role_id=None,
11102        composite_role_id=None,
11103        id=None,
11104    ):
11105        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11106        '''
11107         The id of the attached role of this RoleAttachment.
11108        '''
11109        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11110        '''
11111         The id of the composite role of this RoleAttachment.
11112        '''
11113        self.id = id if id is not None else ''
11114        '''
11115         Unique identifier of the RoleAttachment.
11116        '''
attached_role_id

The id of the attached role of this RoleAttachment.

composite_role_id

The id of the composite role of this RoleAttachment.

id

Unique identifier of the RoleAttachment.

def to_dict(self)
11125    def to_dict(self):
11126        return {
11127            'attached_role_id': self.attached_role_id,
11128            'composite_role_id': self.composite_role_id,
11129            'id': self.id,
11130        }
@classmethod
def from_dict(cls, d)
11132    @classmethod
11133    def from_dict(cls, d):
11134        return cls(
11135            attached_role_id=d.get('attached_role_id'),
11136            composite_role_id=d.get('composite_role_id'),
11137            id=d.get('id'),
11138        )
class RoleAttachmentCreateResponse:
11141class RoleAttachmentCreateResponse:
11142    '''
11143     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
11144     
11145     Deprecated: use multi-role via AccountAttachments instead.
11146    '''
11147    __slots__ = [
11148        'meta',
11149        'rate_limit',
11150        'role_attachment',
11151    ]
11152
11153    def __init__(
11154        self,
11155        meta=None,
11156        rate_limit=None,
11157        role_attachment=None,
11158    ):
11159        self.meta = meta if meta is not None else None
11160        '''
11161         Reserved for future use.
11162        '''
11163        self.rate_limit = rate_limit if rate_limit is not None else None
11164        '''
11165         Rate limit information.
11166        '''
11167        self.role_attachment = role_attachment if role_attachment is not None else None
11168        '''
11169         The created RoleAttachment.
11170        '''
11171
11172    def __repr__(self):
11173        return '<sdm.RoleAttachmentCreateResponse ' + \
11174            'meta: ' + repr(self.meta) + ' ' +\
11175            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11176            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11177            '>'
11178
11179    def to_dict(self):
11180        return {
11181            'meta': self.meta,
11182            'rate_limit': self.rate_limit,
11183            'role_attachment': self.role_attachment,
11184        }
11185
11186    @classmethod
11187    def from_dict(cls, d):
11188        return cls(
11189            meta=d.get('meta'),
11190            rate_limit=d.get('rate_limit'),
11191            role_attachment=d.get('role_attachment'),
11192        )

RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentCreateResponse(meta=None, rate_limit=None, role_attachment=None)
11153    def __init__(
11154        self,
11155        meta=None,
11156        rate_limit=None,
11157        role_attachment=None,
11158    ):
11159        self.meta = meta if meta is not None else None
11160        '''
11161         Reserved for future use.
11162        '''
11163        self.rate_limit = rate_limit if rate_limit is not None else None
11164        '''
11165         Rate limit information.
11166        '''
11167        self.role_attachment = role_attachment if role_attachment is not None else None
11168        '''
11169         The created RoleAttachment.
11170        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_attachment

The created RoleAttachment.

def to_dict(self)
11179    def to_dict(self):
11180        return {
11181            'meta': self.meta,
11182            'rate_limit': self.rate_limit,
11183            'role_attachment': self.role_attachment,
11184        }
@classmethod
def from_dict(cls, d)
11186    @classmethod
11187    def from_dict(cls, d):
11188        return cls(
11189            meta=d.get('meta'),
11190            rate_limit=d.get('rate_limit'),
11191            role_attachment=d.get('role_attachment'),
11192        )
class RoleAttachmentDeleteResponse:
11195class RoleAttachmentDeleteResponse:
11196    '''
11197     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
11198     
11199     Deprecated: use multi-role via AccountAttachments instead.
11200    '''
11201    __slots__ = [
11202        'meta',
11203        'rate_limit',
11204    ]
11205
11206    def __init__(
11207        self,
11208        meta=None,
11209        rate_limit=None,
11210    ):
11211        self.meta = meta if meta is not None else None
11212        '''
11213         Reserved for future use.
11214        '''
11215        self.rate_limit = rate_limit if rate_limit is not None else None
11216        '''
11217         Rate limit information.
11218        '''
11219
11220    def __repr__(self):
11221        return '<sdm.RoleAttachmentDeleteResponse ' + \
11222            'meta: ' + repr(self.meta) + ' ' +\
11223            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11224            '>'
11225
11226    def to_dict(self):
11227        return {
11228            'meta': self.meta,
11229            'rate_limit': self.rate_limit,
11230        }
11231
11232    @classmethod
11233    def from_dict(cls, d):
11234        return cls(
11235            meta=d.get('meta'),
11236            rate_limit=d.get('rate_limit'),
11237        )

RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentDeleteResponse(meta=None, rate_limit=None)
11206    def __init__(
11207        self,
11208        meta=None,
11209        rate_limit=None,
11210    ):
11211        self.meta = meta if meta is not None else None
11212        '''
11213         Reserved for future use.
11214        '''
11215        self.rate_limit = rate_limit if rate_limit is not None else None
11216        '''
11217         Rate limit information.
11218        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11226    def to_dict(self):
11227        return {
11228            'meta': self.meta,
11229            'rate_limit': self.rate_limit,
11230        }
@classmethod
def from_dict(cls, d)
11232    @classmethod
11233    def from_dict(cls, d):
11234        return cls(
11235            meta=d.get('meta'),
11236            rate_limit=d.get('rate_limit'),
11237        )
class RoleAttachmentGetResponse:
11240class RoleAttachmentGetResponse:
11241    '''
11242     RoleAttachmentGetResponse returns a requested RoleAttachment.
11243     
11244     Deprecated: use multi-role via AccountAttachments instead.
11245    '''
11246    __slots__ = [
11247        'meta',
11248        'rate_limit',
11249        'role_attachment',
11250    ]
11251
11252    def __init__(
11253        self,
11254        meta=None,
11255        rate_limit=None,
11256        role_attachment=None,
11257    ):
11258        self.meta = meta if meta is not None else None
11259        '''
11260         Reserved for future use.
11261        '''
11262        self.rate_limit = rate_limit if rate_limit is not None else None
11263        '''
11264         Rate limit information.
11265        '''
11266        self.role_attachment = role_attachment if role_attachment is not None else None
11267        '''
11268         The requested RoleAttachment.
11269        '''
11270
11271    def __repr__(self):
11272        return '<sdm.RoleAttachmentGetResponse ' + \
11273            'meta: ' + repr(self.meta) + ' ' +\
11274            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11275            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11276            '>'
11277
11278    def to_dict(self):
11279        return {
11280            'meta': self.meta,
11281            'rate_limit': self.rate_limit,
11282            'role_attachment': self.role_attachment,
11283        }
11284
11285    @classmethod
11286    def from_dict(cls, d):
11287        return cls(
11288            meta=d.get('meta'),
11289            rate_limit=d.get('rate_limit'),
11290            role_attachment=d.get('role_attachment'),
11291        )

RoleAttachmentGetResponse returns a requested RoleAttachment.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentGetResponse(meta=None, rate_limit=None, role_attachment=None)
11252    def __init__(
11253        self,
11254        meta=None,
11255        rate_limit=None,
11256        role_attachment=None,
11257    ):
11258        self.meta = meta if meta is not None else None
11259        '''
11260         Reserved for future use.
11261        '''
11262        self.rate_limit = rate_limit if rate_limit is not None else None
11263        '''
11264         Rate limit information.
11265        '''
11266        self.role_attachment = role_attachment if role_attachment is not None else None
11267        '''
11268         The requested RoleAttachment.
11269        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_attachment

The requested RoleAttachment.

def to_dict(self)
11278    def to_dict(self):
11279        return {
11280            'meta': self.meta,
11281            'rate_limit': self.rate_limit,
11282            'role_attachment': self.role_attachment,
11283        }
@classmethod
def from_dict(cls, d)
11285    @classmethod
11286    def from_dict(cls, d):
11287        return cls(
11288            meta=d.get('meta'),
11289            rate_limit=d.get('rate_limit'),
11290            role_attachment=d.get('role_attachment'),
11291        )
class RoleCreateResponse:
11294class RoleCreateResponse:
11295    '''
11296     RoleCreateResponse reports how the Roles were created in the system. It can
11297     communicate partial successes or failures.
11298    '''
11299    __slots__ = [
11300        'meta',
11301        'rate_limit',
11302        'role',
11303    ]
11304
11305    def __init__(
11306        self,
11307        meta=None,
11308        rate_limit=None,
11309        role=None,
11310    ):
11311        self.meta = meta if meta is not None else None
11312        '''
11313         Reserved for future use.
11314        '''
11315        self.rate_limit = rate_limit if rate_limit is not None else None
11316        '''
11317         Rate limit information.
11318        '''
11319        self.role = role if role is not None else None
11320        '''
11321         The created Role.
11322        '''
11323
11324    def __repr__(self):
11325        return '<sdm.RoleCreateResponse ' + \
11326            'meta: ' + repr(self.meta) + ' ' +\
11327            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11328            'role: ' + repr(self.role) + ' ' +\
11329            '>'
11330
11331    def to_dict(self):
11332        return {
11333            'meta': self.meta,
11334            'rate_limit': self.rate_limit,
11335            'role': self.role,
11336        }
11337
11338    @classmethod
11339    def from_dict(cls, d):
11340        return cls(
11341            meta=d.get('meta'),
11342            rate_limit=d.get('rate_limit'),
11343            role=d.get('role'),
11344        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
11305    def __init__(
11306        self,
11307        meta=None,
11308        rate_limit=None,
11309        role=None,
11310    ):
11311        self.meta = meta if meta is not None else None
11312        '''
11313         Reserved for future use.
11314        '''
11315        self.rate_limit = rate_limit if rate_limit is not None else None
11316        '''
11317         Rate limit information.
11318        '''
11319        self.role = role if role is not None else None
11320        '''
11321         The created Role.
11322        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
11331    def to_dict(self):
11332        return {
11333            'meta': self.meta,
11334            'rate_limit': self.rate_limit,
11335            'role': self.role,
11336        }
@classmethod
def from_dict(cls, d)
11338    @classmethod
11339    def from_dict(cls, d):
11340        return cls(
11341            meta=d.get('meta'),
11342            rate_limit=d.get('rate_limit'),
11343            role=d.get('role'),
11344        )
class RoleDeleteResponse:
11347class RoleDeleteResponse:
11348    '''
11349     RoleDeleteResponse returns information about a Role that was deleted.
11350    '''
11351    __slots__ = [
11352        'meta',
11353        'rate_limit',
11354    ]
11355
11356    def __init__(
11357        self,
11358        meta=None,
11359        rate_limit=None,
11360    ):
11361        self.meta = meta if meta is not None else None
11362        '''
11363         Reserved for future use.
11364        '''
11365        self.rate_limit = rate_limit if rate_limit is not None else None
11366        '''
11367         Rate limit information.
11368        '''
11369
11370    def __repr__(self):
11371        return '<sdm.RoleDeleteResponse ' + \
11372            'meta: ' + repr(self.meta) + ' ' +\
11373            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11374            '>'
11375
11376    def to_dict(self):
11377        return {
11378            'meta': self.meta,
11379            'rate_limit': self.rate_limit,
11380        }
11381
11382    @classmethod
11383    def from_dict(cls, d):
11384        return cls(
11385            meta=d.get('meta'),
11386            rate_limit=d.get('rate_limit'),
11387        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
11356    def __init__(
11357        self,
11358        meta=None,
11359        rate_limit=None,
11360    ):
11361        self.meta = meta if meta is not None else None
11362        '''
11363         Reserved for future use.
11364        '''
11365        self.rate_limit = rate_limit if rate_limit is not None else None
11366        '''
11367         Rate limit information.
11368        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11376    def to_dict(self):
11377        return {
11378            'meta': self.meta,
11379            'rate_limit': self.rate_limit,
11380        }
@classmethod
def from_dict(cls, d)
11382    @classmethod
11383    def from_dict(cls, d):
11384        return cls(
11385            meta=d.get('meta'),
11386            rate_limit=d.get('rate_limit'),
11387        )
class RoleGetResponse:
11390class RoleGetResponse:
11391    '''
11392     RoleGetResponse returns a requested Role.
11393    '''
11394    __slots__ = [
11395        'meta',
11396        'rate_limit',
11397        'role',
11398    ]
11399
11400    def __init__(
11401        self,
11402        meta=None,
11403        rate_limit=None,
11404        role=None,
11405    ):
11406        self.meta = meta if meta is not None else None
11407        '''
11408         Reserved for future use.
11409        '''
11410        self.rate_limit = rate_limit if rate_limit is not None else None
11411        '''
11412         Rate limit information.
11413        '''
11414        self.role = role if role is not None else None
11415        '''
11416         The requested Role.
11417        '''
11418
11419    def __repr__(self):
11420        return '<sdm.RoleGetResponse ' + \
11421            'meta: ' + repr(self.meta) + ' ' +\
11422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11423            'role: ' + repr(self.role) + ' ' +\
11424            '>'
11425
11426    def to_dict(self):
11427        return {
11428            'meta': self.meta,
11429            'rate_limit': self.rate_limit,
11430            'role': self.role,
11431        }
11432
11433    @classmethod
11434    def from_dict(cls, d):
11435        return cls(
11436            meta=d.get('meta'),
11437            rate_limit=d.get('rate_limit'),
11438            role=d.get('role'),
11439        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
11400    def __init__(
11401        self,
11402        meta=None,
11403        rate_limit=None,
11404        role=None,
11405    ):
11406        self.meta = meta if meta is not None else None
11407        '''
11408         Reserved for future use.
11409        '''
11410        self.rate_limit = rate_limit if rate_limit is not None else None
11411        '''
11412         Rate limit information.
11413        '''
11414        self.role = role if role is not None else None
11415        '''
11416         The requested Role.
11417        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
11426    def to_dict(self):
11427        return {
11428            'meta': self.meta,
11429            'rate_limit': self.rate_limit,
11430            'role': self.role,
11431        }
@classmethod
def from_dict(cls, d)
11433    @classmethod
11434    def from_dict(cls, d):
11435        return cls(
11436            meta=d.get('meta'),
11437            rate_limit=d.get('rate_limit'),
11438            role=d.get('role'),
11439        )
class RoleGrant:
11442class RoleGrant:
11443    '''
11444     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
11445     
11446     Deprecated: use Role access rules instead.
11447    '''
11448    __slots__ = [
11449        'id',
11450        'resource_id',
11451        'role_id',
11452    ]
11453
11454    def __init__(
11455        self,
11456        id=None,
11457        resource_id=None,
11458        role_id=None,
11459    ):
11460        self.id = id if id is not None else ''
11461        '''
11462         Unique identifier of the RoleGrant.
11463        '''
11464        self.resource_id = resource_id if resource_id is not None else ''
11465        '''
11466         The id of the resource of this RoleGrant.
11467        '''
11468        self.role_id = role_id if role_id is not None else ''
11469        '''
11470         The id of the attached role of this RoleGrant.
11471        '''
11472
11473    def __repr__(self):
11474        return '<sdm.RoleGrant ' + \
11475            'id: ' + repr(self.id) + ' ' +\
11476            'resource_id: ' + repr(self.resource_id) + ' ' +\
11477            'role_id: ' + repr(self.role_id) + ' ' +\
11478            '>'
11479
11480    def to_dict(self):
11481        return {
11482            'id': self.id,
11483            'resource_id': self.resource_id,
11484            'role_id': self.role_id,
11485        }
11486
11487    @classmethod
11488    def from_dict(cls, d):
11489        return cls(
11490            id=d.get('id'),
11491            resource_id=d.get('resource_id'),
11492            role_id=d.get('role_id'),
11493        )

A RoleGrant connects a resource to a role, granting members of the role access to that resource.

Deprecated: use Role access rules instead.

RoleGrant(id=None, resource_id=None, role_id=None)
11454    def __init__(
11455        self,
11456        id=None,
11457        resource_id=None,
11458        role_id=None,
11459    ):
11460        self.id = id if id is not None else ''
11461        '''
11462         Unique identifier of the RoleGrant.
11463        '''
11464        self.resource_id = resource_id if resource_id is not None else ''
11465        '''
11466         The id of the resource of this RoleGrant.
11467        '''
11468        self.role_id = role_id if role_id is not None else ''
11469        '''
11470         The id of the attached role of this RoleGrant.
11471        '''
id

Unique identifier of the RoleGrant.

resource_id

The id of the resource of this RoleGrant.

role_id

The id of the attached role of this RoleGrant.

def to_dict(self)
11480    def to_dict(self):
11481        return {
11482            'id': self.id,
11483            'resource_id': self.resource_id,
11484            'role_id': self.role_id,
11485        }
@classmethod
def from_dict(cls, d)
11487    @classmethod
11488    def from_dict(cls, d):
11489        return cls(
11490            id=d.get('id'),
11491            resource_id=d.get('resource_id'),
11492            role_id=d.get('role_id'),
11493        )
class RoleGrantCreateResponse:
11496class RoleGrantCreateResponse:
11497    '''
11498     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
11499     
11500     Deprecated: use Role access rules instead.
11501    '''
11502    __slots__ = [
11503        'meta',
11504        'rate_limit',
11505        'role_grant',
11506    ]
11507
11508    def __init__(
11509        self,
11510        meta=None,
11511        rate_limit=None,
11512        role_grant=None,
11513    ):
11514        self.meta = meta if meta is not None else None
11515        '''
11516         Reserved for future use.
11517        '''
11518        self.rate_limit = rate_limit if rate_limit is not None else None
11519        '''
11520         Rate limit information.
11521        '''
11522        self.role_grant = role_grant if role_grant is not None else None
11523        '''
11524         The created RoleGrant.
11525        '''
11526
11527    def __repr__(self):
11528        return '<sdm.RoleGrantCreateResponse ' + \
11529            'meta: ' + repr(self.meta) + ' ' +\
11530            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11531            'role_grant: ' + repr(self.role_grant) + ' ' +\
11532            '>'
11533
11534    def to_dict(self):
11535        return {
11536            'meta': self.meta,
11537            'rate_limit': self.rate_limit,
11538            'role_grant': self.role_grant,
11539        }
11540
11541    @classmethod
11542    def from_dict(cls, d):
11543        return cls(
11544            meta=d.get('meta'),
11545            rate_limit=d.get('rate_limit'),
11546            role_grant=d.get('role_grant'),
11547        )

RoleGrantCreateResponse reports how the RoleGrants were created in the system.

Deprecated: use Role access rules instead.

RoleGrantCreateResponse(meta=None, rate_limit=None, role_grant=None)
11508    def __init__(
11509        self,
11510        meta=None,
11511        rate_limit=None,
11512        role_grant=None,
11513    ):
11514        self.meta = meta if meta is not None else None
11515        '''
11516         Reserved for future use.
11517        '''
11518        self.rate_limit = rate_limit if rate_limit is not None else None
11519        '''
11520         Rate limit information.
11521        '''
11522        self.role_grant = role_grant if role_grant is not None else None
11523        '''
11524         The created RoleGrant.
11525        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_grant

The created RoleGrant.

def to_dict(self)
11534    def to_dict(self):
11535        return {
11536            'meta': self.meta,
11537            'rate_limit': self.rate_limit,
11538            'role_grant': self.role_grant,
11539        }
@classmethod
def from_dict(cls, d)
11541    @classmethod
11542    def from_dict(cls, d):
11543        return cls(
11544            meta=d.get('meta'),
11545            rate_limit=d.get('rate_limit'),
11546            role_grant=d.get('role_grant'),
11547        )
class RoleGrantDeleteResponse:
11550class RoleGrantDeleteResponse:
11551    '''
11552     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
11553     
11554     Deprecated: use Role access rules instead.
11555    '''
11556    __slots__ = [
11557        'meta',
11558        'rate_limit',
11559    ]
11560
11561    def __init__(
11562        self,
11563        meta=None,
11564        rate_limit=None,
11565    ):
11566        self.meta = meta if meta is not None else None
11567        '''
11568         Reserved for future use.
11569        '''
11570        self.rate_limit = rate_limit if rate_limit is not None else None
11571        '''
11572         Rate limit information.
11573        '''
11574
11575    def __repr__(self):
11576        return '<sdm.RoleGrantDeleteResponse ' + \
11577            'meta: ' + repr(self.meta) + ' ' +\
11578            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11579            '>'
11580
11581    def to_dict(self):
11582        return {
11583            'meta': self.meta,
11584            'rate_limit': self.rate_limit,
11585        }
11586
11587    @classmethod
11588    def from_dict(cls, d):
11589        return cls(
11590            meta=d.get('meta'),
11591            rate_limit=d.get('rate_limit'),
11592        )

RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

Deprecated: use Role access rules instead.

RoleGrantDeleteResponse(meta=None, rate_limit=None)
11561    def __init__(
11562        self,
11563        meta=None,
11564        rate_limit=None,
11565    ):
11566        self.meta = meta if meta is not None else None
11567        '''
11568         Reserved for future use.
11569        '''
11570        self.rate_limit = rate_limit if rate_limit is not None else None
11571        '''
11572         Rate limit information.
11573        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11581    def to_dict(self):
11582        return {
11583            'meta': self.meta,
11584            'rate_limit': self.rate_limit,
11585        }
@classmethod
def from_dict(cls, d)
11587    @classmethod
11588    def from_dict(cls, d):
11589        return cls(
11590            meta=d.get('meta'),
11591            rate_limit=d.get('rate_limit'),
11592        )
class RoleGrantGetResponse:
11595class RoleGrantGetResponse:
11596    '''
11597     RoleGrantGetResponse returns a requested RoleGrant.
11598     
11599     Deprecated: use Role access rules instead.
11600    '''
11601    __slots__ = [
11602        'meta',
11603        'rate_limit',
11604        'role_grant',
11605    ]
11606
11607    def __init__(
11608        self,
11609        meta=None,
11610        rate_limit=None,
11611        role_grant=None,
11612    ):
11613        self.meta = meta if meta is not None else None
11614        '''
11615         Reserved for future use.
11616        '''
11617        self.rate_limit = rate_limit if rate_limit is not None else None
11618        '''
11619         Rate limit information.
11620        '''
11621        self.role_grant = role_grant if role_grant is not None else None
11622        '''
11623         The requested RoleGrant.
11624        '''
11625
11626    def __repr__(self):
11627        return '<sdm.RoleGrantGetResponse ' + \
11628            'meta: ' + repr(self.meta) + ' ' +\
11629            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11630            'role_grant: ' + repr(self.role_grant) + ' ' +\
11631            '>'
11632
11633    def to_dict(self):
11634        return {
11635            'meta': self.meta,
11636            'rate_limit': self.rate_limit,
11637            'role_grant': self.role_grant,
11638        }
11639
11640    @classmethod
11641    def from_dict(cls, d):
11642        return cls(
11643            meta=d.get('meta'),
11644            rate_limit=d.get('rate_limit'),
11645            role_grant=d.get('role_grant'),
11646        )

RoleGrantGetResponse returns a requested RoleGrant.

Deprecated: use Role access rules instead.

RoleGrantGetResponse(meta=None, rate_limit=None, role_grant=None)
11607    def __init__(
11608        self,
11609        meta=None,
11610        rate_limit=None,
11611        role_grant=None,
11612    ):
11613        self.meta = meta if meta is not None else None
11614        '''
11615         Reserved for future use.
11616        '''
11617        self.rate_limit = rate_limit if rate_limit is not None else None
11618        '''
11619         Rate limit information.
11620        '''
11621        self.role_grant = role_grant if role_grant is not None else None
11622        '''
11623         The requested RoleGrant.
11624        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_grant

The requested RoleGrant.

def to_dict(self)
11633    def to_dict(self):
11634        return {
11635            'meta': self.meta,
11636            'rate_limit': self.rate_limit,
11637            'role_grant': self.role_grant,
11638        }
@classmethod
def from_dict(cls, d)
11640    @classmethod
11641    def from_dict(cls, d):
11642        return cls(
11643            meta=d.get('meta'),
11644            rate_limit=d.get('rate_limit'),
11645            role_grant=d.get('role_grant'),
11646        )
class RoleUpdateResponse:
11649class RoleUpdateResponse:
11650    '''
11651     RoleUpdateResponse returns the fields of a Role after it has been updated by
11652     a RoleUpdateRequest.
11653    '''
11654    __slots__ = [
11655        'meta',
11656        'rate_limit',
11657        'role',
11658    ]
11659
11660    def __init__(
11661        self,
11662        meta=None,
11663        rate_limit=None,
11664        role=None,
11665    ):
11666        self.meta = meta if meta is not None else None
11667        '''
11668         Reserved for future use.
11669        '''
11670        self.rate_limit = rate_limit if rate_limit is not None else None
11671        '''
11672         Rate limit information.
11673        '''
11674        self.role = role if role is not None else None
11675        '''
11676         The updated Role.
11677        '''
11678
11679    def __repr__(self):
11680        return '<sdm.RoleUpdateResponse ' + \
11681            'meta: ' + repr(self.meta) + ' ' +\
11682            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11683            'role: ' + repr(self.role) + ' ' +\
11684            '>'
11685
11686    def to_dict(self):
11687        return {
11688            'meta': self.meta,
11689            'rate_limit': self.rate_limit,
11690            'role': self.role,
11691        }
11692
11693    @classmethod
11694    def from_dict(cls, d):
11695        return cls(
11696            meta=d.get('meta'),
11697            rate_limit=d.get('rate_limit'),
11698            role=d.get('role'),
11699        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
11660    def __init__(
11661        self,
11662        meta=None,
11663        rate_limit=None,
11664        role=None,
11665    ):
11666        self.meta = meta if meta is not None else None
11667        '''
11668         Reserved for future use.
11669        '''
11670        self.rate_limit = rate_limit if rate_limit is not None else None
11671        '''
11672         Rate limit information.
11673        '''
11674        self.role = role if role is not None else None
11675        '''
11676         The updated Role.
11677        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
11686    def to_dict(self):
11687        return {
11688            'meta': self.meta,
11689            'rate_limit': self.rate_limit,
11690            'role': self.role,
11691        }
@classmethod
def from_dict(cls, d)
11693    @classmethod
11694    def from_dict(cls, d):
11695        return cls(
11696            meta=d.get('meta'),
11697            rate_limit=d.get('rate_limit'),
11698            role=d.get('role'),
11699        )
class SQLServer:
11702class SQLServer:
11703    '''
11704
11705    '''
11706    __slots__ = [
11707        'bind_interface',
11708        'database',
11709        'egress_filter',
11710        'healthy',
11711        'hostname',
11712        'id',
11713        'name',
11714        'override_database',
11715        'password',
11716        'port',
11717        'port_override',
11718        'schema',
11719        'secret_store_id',
11720        'tags',
11721        'username',
11722    ]
11723
11724    def __init__(
11725        self,
11726        bind_interface=None,
11727        database=None,
11728        egress_filter=None,
11729        healthy=None,
11730        hostname=None,
11731        id=None,
11732        name=None,
11733        override_database=None,
11734        password=None,
11735        port=None,
11736        port_override=None,
11737        schema=None,
11738        secret_store_id=None,
11739        tags=None,
11740        username=None,
11741    ):
11742        self.bind_interface = bind_interface if bind_interface is not None else ''
11743        '''
11744         Bind interface
11745        '''
11746        self.database = database if database is not None else ''
11747        '''
11748
11749        '''
11750        self.egress_filter = egress_filter if egress_filter is not None else ''
11751        '''
11752         A filter applied to the routing logic to pin datasource to nodes.
11753        '''
11754        self.healthy = healthy if healthy is not None else False
11755        '''
11756         True if the datasource is reachable and the credentials are valid.
11757        '''
11758        self.hostname = hostname if hostname is not None else ''
11759        '''
11760
11761        '''
11762        self.id = id if id is not None else ''
11763        '''
11764         Unique identifier of the Resource.
11765        '''
11766        self.name = name if name is not None else ''
11767        '''
11768         Unique human-readable name of the Resource.
11769        '''
11770        self.override_database = override_database if override_database is not None else False
11771        '''
11772
11773        '''
11774        self.password = password if password is not None else ''
11775        '''
11776
11777        '''
11778        self.port = port if port is not None else 0
11779        '''
11780
11781        '''
11782        self.port_override = port_override if port_override is not None else 0
11783        '''
11784
11785        '''
11786        self.schema = schema if schema is not None else ''
11787        '''
11788
11789        '''
11790        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11791        '''
11792         ID of the secret store containing credentials for this resource, if any.
11793        '''
11794        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11795        '''
11796         Tags is a map of key, value pairs.
11797        '''
11798        self.username = username if username is not None else ''
11799        '''
11800
11801        '''
11802
11803    def __repr__(self):
11804        return '<sdm.SQLServer ' + \
11805            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11806            'database: ' + repr(self.database) + ' ' +\
11807            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11808            'healthy: ' + repr(self.healthy) + ' ' +\
11809            'hostname: ' + repr(self.hostname) + ' ' +\
11810            'id: ' + repr(self.id) + ' ' +\
11811            'name: ' + repr(self.name) + ' ' +\
11812            'override_database: ' + repr(self.override_database) + ' ' +\
11813            'password: ' + repr(self.password) + ' ' +\
11814            'port: ' + repr(self.port) + ' ' +\
11815            'port_override: ' + repr(self.port_override) + ' ' +\
11816            'schema: ' + repr(self.schema) + ' ' +\
11817            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11818            'tags: ' + repr(self.tags) + ' ' +\
11819            'username: ' + repr(self.username) + ' ' +\
11820            '>'
11821
11822    def to_dict(self):
11823        return {
11824            'bind_interface': self.bind_interface,
11825            'database': self.database,
11826            'egress_filter': self.egress_filter,
11827            'healthy': self.healthy,
11828            'hostname': self.hostname,
11829            'id': self.id,
11830            'name': self.name,
11831            'override_database': self.override_database,
11832            'password': self.password,
11833            'port': self.port,
11834            'port_override': self.port_override,
11835            'schema': self.schema,
11836            'secret_store_id': self.secret_store_id,
11837            'tags': self.tags,
11838            'username': self.username,
11839        }
11840
11841    @classmethod
11842    def from_dict(cls, d):
11843        return cls(
11844            bind_interface=d.get('bind_interface'),
11845            database=d.get('database'),
11846            egress_filter=d.get('egress_filter'),
11847            healthy=d.get('healthy'),
11848            hostname=d.get('hostname'),
11849            id=d.get('id'),
11850            name=d.get('name'),
11851            override_database=d.get('override_database'),
11852            password=d.get('password'),
11853            port=d.get('port'),
11854            port_override=d.get('port_override'),
11855            schema=d.get('schema'),
11856            secret_store_id=d.get('secret_store_id'),
11857            tags=d.get('tags'),
11858            username=d.get('username'),
11859        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11724    def __init__(
11725        self,
11726        bind_interface=None,
11727        database=None,
11728        egress_filter=None,
11729        healthy=None,
11730        hostname=None,
11731        id=None,
11732        name=None,
11733        override_database=None,
11734        password=None,
11735        port=None,
11736        port_override=None,
11737        schema=None,
11738        secret_store_id=None,
11739        tags=None,
11740        username=None,
11741    ):
11742        self.bind_interface = bind_interface if bind_interface is not None else ''
11743        '''
11744         Bind interface
11745        '''
11746        self.database = database if database is not None else ''
11747        '''
11748
11749        '''
11750        self.egress_filter = egress_filter if egress_filter is not None else ''
11751        '''
11752         A filter applied to the routing logic to pin datasource to nodes.
11753        '''
11754        self.healthy = healthy if healthy is not None else False
11755        '''
11756         True if the datasource is reachable and the credentials are valid.
11757        '''
11758        self.hostname = hostname if hostname is not None else ''
11759        '''
11760
11761        '''
11762        self.id = id if id is not None else ''
11763        '''
11764         Unique identifier of the Resource.
11765        '''
11766        self.name = name if name is not None else ''
11767        '''
11768         Unique human-readable name of the Resource.
11769        '''
11770        self.override_database = override_database if override_database is not None else False
11771        '''
11772
11773        '''
11774        self.password = password if password is not None else ''
11775        '''
11776
11777        '''
11778        self.port = port if port is not None else 0
11779        '''
11780
11781        '''
11782        self.port_override = port_override if port_override is not None else 0
11783        '''
11784
11785        '''
11786        self.schema = schema if schema is not None else ''
11787        '''
11788
11789        '''
11790        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11791        '''
11792         ID of the secret store containing credentials for this resource, if any.
11793        '''
11794        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11795        '''
11796         Tags is a map of key, value pairs.
11797        '''
11798        self.username = username if username is not None else ''
11799        '''
11800
11801        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11822    def to_dict(self):
11823        return {
11824            'bind_interface': self.bind_interface,
11825            'database': self.database,
11826            'egress_filter': self.egress_filter,
11827            'healthy': self.healthy,
11828            'hostname': self.hostname,
11829            'id': self.id,
11830            'name': self.name,
11831            'override_database': self.override_database,
11832            'password': self.password,
11833            'port': self.port,
11834            'port_override': self.port_override,
11835            'schema': self.schema,
11836            'secret_store_id': self.secret_store_id,
11837            'tags': self.tags,
11838            'username': self.username,
11839        }
@classmethod
def from_dict(cls, d)
11841    @classmethod
11842    def from_dict(cls, d):
11843        return cls(
11844            bind_interface=d.get('bind_interface'),
11845            database=d.get('database'),
11846            egress_filter=d.get('egress_filter'),
11847            healthy=d.get('healthy'),
11848            hostname=d.get('hostname'),
11849            id=d.get('id'),
11850            name=d.get('name'),
11851            override_database=d.get('override_database'),
11852            password=d.get('password'),
11853            port=d.get('port'),
11854            port_override=d.get('port_override'),
11855            schema=d.get('schema'),
11856            secret_store_id=d.get('secret_store_id'),
11857            tags=d.get('tags'),
11858            username=d.get('username'),
11859        )
class SSH:
11862class SSH:
11863    '''
11864
11865    '''
11866    __slots__ = [
11867        'allow_deprecated_key_exchanges',
11868        'bind_interface',
11869        'egress_filter',
11870        'healthy',
11871        'hostname',
11872        'id',
11873        'key_type',
11874        'name',
11875        'port',
11876        'port_forwarding',
11877        'port_override',
11878        'public_key',
11879        'secret_store_id',
11880        'tags',
11881        'username',
11882    ]
11883
11884    def __init__(
11885        self,
11886        allow_deprecated_key_exchanges=None,
11887        bind_interface=None,
11888        egress_filter=None,
11889        healthy=None,
11890        hostname=None,
11891        id=None,
11892        key_type=None,
11893        name=None,
11894        port=None,
11895        port_forwarding=None,
11896        port_override=None,
11897        public_key=None,
11898        secret_store_id=None,
11899        tags=None,
11900        username=None,
11901    ):
11902        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11903        '''
11904
11905        '''
11906        self.bind_interface = bind_interface if bind_interface is not None else ''
11907        '''
11908         Bind interface
11909        '''
11910        self.egress_filter = egress_filter if egress_filter is not None else ''
11911        '''
11912         A filter applied to the routing logic to pin datasource to nodes.
11913        '''
11914        self.healthy = healthy if healthy is not None else False
11915        '''
11916         True if the datasource is reachable and the credentials are valid.
11917        '''
11918        self.hostname = hostname if hostname is not None else ''
11919        '''
11920
11921        '''
11922        self.id = id if id is not None else ''
11923        '''
11924         Unique identifier of the Resource.
11925        '''
11926        self.key_type = key_type if key_type is not None else ''
11927        '''
11928
11929        '''
11930        self.name = name if name is not None else ''
11931        '''
11932         Unique human-readable name of the Resource.
11933        '''
11934        self.port = port if port is not None else 0
11935        '''
11936
11937        '''
11938        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11939        '''
11940
11941        '''
11942        self.port_override = port_override if port_override is not None else 0
11943        '''
11944
11945        '''
11946        self.public_key = public_key if public_key is not None else ''
11947        '''
11948
11949        '''
11950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11951        '''
11952         ID of the secret store containing credentials for this resource, if any.
11953        '''
11954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11955        '''
11956         Tags is a map of key, value pairs.
11957        '''
11958        self.username = username if username is not None else ''
11959        '''
11960
11961        '''
11962
11963    def __repr__(self):
11964        return '<sdm.SSH ' + \
11965            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11966            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11967            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11968            'healthy: ' + repr(self.healthy) + ' ' +\
11969            'hostname: ' + repr(self.hostname) + ' ' +\
11970            'id: ' + repr(self.id) + ' ' +\
11971            'key_type: ' + repr(self.key_type) + ' ' +\
11972            'name: ' + repr(self.name) + ' ' +\
11973            'port: ' + repr(self.port) + ' ' +\
11974            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11975            'port_override: ' + repr(self.port_override) + ' ' +\
11976            'public_key: ' + repr(self.public_key) + ' ' +\
11977            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11978            'tags: ' + repr(self.tags) + ' ' +\
11979            'username: ' + repr(self.username) + ' ' +\
11980            '>'
11981
11982    def to_dict(self):
11983        return {
11984            'allow_deprecated_key_exchanges':
11985            self.allow_deprecated_key_exchanges,
11986            'bind_interface': self.bind_interface,
11987            'egress_filter': self.egress_filter,
11988            'healthy': self.healthy,
11989            'hostname': self.hostname,
11990            'id': self.id,
11991            'key_type': self.key_type,
11992            'name': self.name,
11993            'port': self.port,
11994            'port_forwarding': self.port_forwarding,
11995            'port_override': self.port_override,
11996            'public_key': self.public_key,
11997            'secret_store_id': self.secret_store_id,
11998            'tags': self.tags,
11999            'username': self.username,
12000        }
12001
12002    @classmethod
12003    def from_dict(cls, d):
12004        return cls(
12005            allow_deprecated_key_exchanges=d.get(
12006                'allow_deprecated_key_exchanges'),
12007            bind_interface=d.get('bind_interface'),
12008            egress_filter=d.get('egress_filter'),
12009            healthy=d.get('healthy'),
12010            hostname=d.get('hostname'),
12011            id=d.get('id'),
12012            key_type=d.get('key_type'),
12013            name=d.get('name'),
12014            port=d.get('port'),
12015            port_forwarding=d.get('port_forwarding'),
12016            port_override=d.get('port_override'),
12017            public_key=d.get('public_key'),
12018            secret_store_id=d.get('secret_store_id'),
12019            tags=d.get('tags'),
12020            username=d.get('username'),
12021        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
11884    def __init__(
11885        self,
11886        allow_deprecated_key_exchanges=None,
11887        bind_interface=None,
11888        egress_filter=None,
11889        healthy=None,
11890        hostname=None,
11891        id=None,
11892        key_type=None,
11893        name=None,
11894        port=None,
11895        port_forwarding=None,
11896        port_override=None,
11897        public_key=None,
11898        secret_store_id=None,
11899        tags=None,
11900        username=None,
11901    ):
11902        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11903        '''
11904
11905        '''
11906        self.bind_interface = bind_interface if bind_interface is not None else ''
11907        '''
11908         Bind interface
11909        '''
11910        self.egress_filter = egress_filter if egress_filter is not None else ''
11911        '''
11912         A filter applied to the routing logic to pin datasource to nodes.
11913        '''
11914        self.healthy = healthy if healthy is not None else False
11915        '''
11916         True if the datasource is reachable and the credentials are valid.
11917        '''
11918        self.hostname = hostname if hostname is not None else ''
11919        '''
11920
11921        '''
11922        self.id = id if id is not None else ''
11923        '''
11924         Unique identifier of the Resource.
11925        '''
11926        self.key_type = key_type if key_type is not None else ''
11927        '''
11928
11929        '''
11930        self.name = name if name is not None else ''
11931        '''
11932         Unique human-readable name of the Resource.
11933        '''
11934        self.port = port if port is not None else 0
11935        '''
11936
11937        '''
11938        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11939        '''
11940
11941        '''
11942        self.port_override = port_override if port_override is not None else 0
11943        '''
11944
11945        '''
11946        self.public_key = public_key if public_key is not None else ''
11947        '''
11948
11949        '''
11950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11951        '''
11952         ID of the secret store containing credentials for this resource, if any.
11953        '''
11954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11955        '''
11956         Tags is a map of key, value pairs.
11957        '''
11958        self.username = username if username is not None else ''
11959        '''
11960
11961        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11982    def to_dict(self):
11983        return {
11984            'allow_deprecated_key_exchanges':
11985            self.allow_deprecated_key_exchanges,
11986            'bind_interface': self.bind_interface,
11987            'egress_filter': self.egress_filter,
11988            'healthy': self.healthy,
11989            'hostname': self.hostname,
11990            'id': self.id,
11991            'key_type': self.key_type,
11992            'name': self.name,
11993            'port': self.port,
11994            'port_forwarding': self.port_forwarding,
11995            'port_override': self.port_override,
11996            'public_key': self.public_key,
11997            'secret_store_id': self.secret_store_id,
11998            'tags': self.tags,
11999            'username': self.username,
12000        }
@classmethod
def from_dict(cls, d)
12002    @classmethod
12003    def from_dict(cls, d):
12004        return cls(
12005            allow_deprecated_key_exchanges=d.get(
12006                'allow_deprecated_key_exchanges'),
12007            bind_interface=d.get('bind_interface'),
12008            egress_filter=d.get('egress_filter'),
12009            healthy=d.get('healthy'),
12010            hostname=d.get('hostname'),
12011            id=d.get('id'),
12012            key_type=d.get('key_type'),
12013            name=d.get('name'),
12014            port=d.get('port'),
12015            port_forwarding=d.get('port_forwarding'),
12016            port_override=d.get('port_override'),
12017            public_key=d.get('public_key'),
12018            secret_store_id=d.get('secret_store_id'),
12019            tags=d.get('tags'),
12020            username=d.get('username'),
12021        )
class SSHCert:
12024class SSHCert:
12025    '''
12026
12027    '''
12028    __slots__ = [
12029        'allow_deprecated_key_exchanges',
12030        'bind_interface',
12031        'egress_filter',
12032        'healthy',
12033        'hostname',
12034        'id',
12035        'key_type',
12036        'name',
12037        'port',
12038        'port_forwarding',
12039        'port_override',
12040        'remote_identity_group_id',
12041        'remote_identity_healthcheck_username',
12042        'secret_store_id',
12043        'tags',
12044        'username',
12045    ]
12046
12047    def __init__(
12048        self,
12049        allow_deprecated_key_exchanges=None,
12050        bind_interface=None,
12051        egress_filter=None,
12052        healthy=None,
12053        hostname=None,
12054        id=None,
12055        key_type=None,
12056        name=None,
12057        port=None,
12058        port_forwarding=None,
12059        port_override=None,
12060        remote_identity_group_id=None,
12061        remote_identity_healthcheck_username=None,
12062        secret_store_id=None,
12063        tags=None,
12064        username=None,
12065    ):
12066        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12067        '''
12068
12069        '''
12070        self.bind_interface = bind_interface if bind_interface is not None else ''
12071        '''
12072         Bind interface
12073        '''
12074        self.egress_filter = egress_filter if egress_filter is not None else ''
12075        '''
12076         A filter applied to the routing logic to pin datasource to nodes.
12077        '''
12078        self.healthy = healthy if healthy is not None else False
12079        '''
12080         True if the datasource is reachable and the credentials are valid.
12081        '''
12082        self.hostname = hostname if hostname is not None else ''
12083        '''
12084
12085        '''
12086        self.id = id if id is not None else ''
12087        '''
12088         Unique identifier of the Resource.
12089        '''
12090        self.key_type = key_type if key_type is not None else ''
12091        '''
12092
12093        '''
12094        self.name = name if name is not None else ''
12095        '''
12096         Unique human-readable name of the Resource.
12097        '''
12098        self.port = port if port is not None else 0
12099        '''
12100
12101        '''
12102        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12103        '''
12104
12105        '''
12106        self.port_override = port_override if port_override is not None else 0
12107        '''
12108
12109        '''
12110        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12111        '''
12112
12113        '''
12114        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12115        '''
12116
12117        '''
12118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12119        '''
12120         ID of the secret store containing credentials for this resource, if any.
12121        '''
12122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12123        '''
12124         Tags is a map of key, value pairs.
12125        '''
12126        self.username = username if username is not None else ''
12127        '''
12128
12129        '''
12130
12131    def __repr__(self):
12132        return '<sdm.SSHCert ' + \
12133            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12136            'healthy: ' + repr(self.healthy) + ' ' +\
12137            'hostname: ' + repr(self.hostname) + ' ' +\
12138            'id: ' + repr(self.id) + ' ' +\
12139            'key_type: ' + repr(self.key_type) + ' ' +\
12140            'name: ' + repr(self.name) + ' ' +\
12141            'port: ' + repr(self.port) + ' ' +\
12142            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12143            'port_override: ' + repr(self.port_override) + ' ' +\
12144            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
12145            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
12146            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12147            'tags: ' + repr(self.tags) + ' ' +\
12148            'username: ' + repr(self.username) + ' ' +\
12149            '>'
12150
12151    def to_dict(self):
12152        return {
12153            'allow_deprecated_key_exchanges':
12154            self.allow_deprecated_key_exchanges,
12155            'bind_interface': self.bind_interface,
12156            'egress_filter': self.egress_filter,
12157            'healthy': self.healthy,
12158            'hostname': self.hostname,
12159            'id': self.id,
12160            'key_type': self.key_type,
12161            'name': self.name,
12162            'port': self.port,
12163            'port_forwarding': self.port_forwarding,
12164            'port_override': self.port_override,
12165            'remote_identity_group_id': self.remote_identity_group_id,
12166            'remote_identity_healthcheck_username':
12167            self.remote_identity_healthcheck_username,
12168            'secret_store_id': self.secret_store_id,
12169            'tags': self.tags,
12170            'username': self.username,
12171        }
12172
12173    @classmethod
12174    def from_dict(cls, d):
12175        return cls(
12176            allow_deprecated_key_exchanges=d.get(
12177                'allow_deprecated_key_exchanges'),
12178            bind_interface=d.get('bind_interface'),
12179            egress_filter=d.get('egress_filter'),
12180            healthy=d.get('healthy'),
12181            hostname=d.get('hostname'),
12182            id=d.get('id'),
12183            key_type=d.get('key_type'),
12184            name=d.get('name'),
12185            port=d.get('port'),
12186            port_forwarding=d.get('port_forwarding'),
12187            port_override=d.get('port_override'),
12188            remote_identity_group_id=d.get('remote_identity_group_id'),
12189            remote_identity_healthcheck_username=d.get(
12190                'remote_identity_healthcheck_username'),
12191            secret_store_id=d.get('secret_store_id'),
12192            tags=d.get('tags'),
12193            username=d.get('username'),
12194        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
12047    def __init__(
12048        self,
12049        allow_deprecated_key_exchanges=None,
12050        bind_interface=None,
12051        egress_filter=None,
12052        healthy=None,
12053        hostname=None,
12054        id=None,
12055        key_type=None,
12056        name=None,
12057        port=None,
12058        port_forwarding=None,
12059        port_override=None,
12060        remote_identity_group_id=None,
12061        remote_identity_healthcheck_username=None,
12062        secret_store_id=None,
12063        tags=None,
12064        username=None,
12065    ):
12066        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12067        '''
12068
12069        '''
12070        self.bind_interface = bind_interface if bind_interface is not None else ''
12071        '''
12072         Bind interface
12073        '''
12074        self.egress_filter = egress_filter if egress_filter is not None else ''
12075        '''
12076         A filter applied to the routing logic to pin datasource to nodes.
12077        '''
12078        self.healthy = healthy if healthy is not None else False
12079        '''
12080         True if the datasource is reachable and the credentials are valid.
12081        '''
12082        self.hostname = hostname if hostname is not None else ''
12083        '''
12084
12085        '''
12086        self.id = id if id is not None else ''
12087        '''
12088         Unique identifier of the Resource.
12089        '''
12090        self.key_type = key_type if key_type is not None else ''
12091        '''
12092
12093        '''
12094        self.name = name if name is not None else ''
12095        '''
12096         Unique human-readable name of the Resource.
12097        '''
12098        self.port = port if port is not None else 0
12099        '''
12100
12101        '''
12102        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12103        '''
12104
12105        '''
12106        self.port_override = port_override if port_override is not None else 0
12107        '''
12108
12109        '''
12110        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12111        '''
12112
12113        '''
12114        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12115        '''
12116
12117        '''
12118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12119        '''
12120         ID of the secret store containing credentials for this resource, if any.
12121        '''
12122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12123        '''
12124         Tags is a map of key, value pairs.
12125        '''
12126        self.username = username if username is not None else ''
12127        '''
12128
12129        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12151    def to_dict(self):
12152        return {
12153            'allow_deprecated_key_exchanges':
12154            self.allow_deprecated_key_exchanges,
12155            'bind_interface': self.bind_interface,
12156            'egress_filter': self.egress_filter,
12157            'healthy': self.healthy,
12158            'hostname': self.hostname,
12159            'id': self.id,
12160            'key_type': self.key_type,
12161            'name': self.name,
12162            'port': self.port,
12163            'port_forwarding': self.port_forwarding,
12164            'port_override': self.port_override,
12165            'remote_identity_group_id': self.remote_identity_group_id,
12166            'remote_identity_healthcheck_username':
12167            self.remote_identity_healthcheck_username,
12168            'secret_store_id': self.secret_store_id,
12169            'tags': self.tags,
12170            'username': self.username,
12171        }
@classmethod
def from_dict(cls, d)
12173    @classmethod
12174    def from_dict(cls, d):
12175        return cls(
12176            allow_deprecated_key_exchanges=d.get(
12177                'allow_deprecated_key_exchanges'),
12178            bind_interface=d.get('bind_interface'),
12179            egress_filter=d.get('egress_filter'),
12180            healthy=d.get('healthy'),
12181            hostname=d.get('hostname'),
12182            id=d.get('id'),
12183            key_type=d.get('key_type'),
12184            name=d.get('name'),
12185            port=d.get('port'),
12186            port_forwarding=d.get('port_forwarding'),
12187            port_override=d.get('port_override'),
12188            remote_identity_group_id=d.get('remote_identity_group_id'),
12189            remote_identity_healthcheck_username=d.get(
12190                'remote_identity_healthcheck_username'),
12191            secret_store_id=d.get('secret_store_id'),
12192            tags=d.get('tags'),
12193            username=d.get('username'),
12194        )
class SSHCustomerKey:
12197class SSHCustomerKey:
12198    '''
12199
12200    '''
12201    __slots__ = [
12202        'allow_deprecated_key_exchanges',
12203        'bind_interface',
12204        'egress_filter',
12205        'healthy',
12206        'hostname',
12207        'id',
12208        'name',
12209        'port',
12210        'port_forwarding',
12211        'port_override',
12212        'private_key',
12213        'secret_store_id',
12214        'tags',
12215        'username',
12216    ]
12217
12218    def __init__(
12219        self,
12220        allow_deprecated_key_exchanges=None,
12221        bind_interface=None,
12222        egress_filter=None,
12223        healthy=None,
12224        hostname=None,
12225        id=None,
12226        name=None,
12227        port=None,
12228        port_forwarding=None,
12229        port_override=None,
12230        private_key=None,
12231        secret_store_id=None,
12232        tags=None,
12233        username=None,
12234    ):
12235        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12236        '''
12237
12238        '''
12239        self.bind_interface = bind_interface if bind_interface is not None else ''
12240        '''
12241         Bind interface
12242        '''
12243        self.egress_filter = egress_filter if egress_filter is not None else ''
12244        '''
12245         A filter applied to the routing logic to pin datasource to nodes.
12246        '''
12247        self.healthy = healthy if healthy is not None else False
12248        '''
12249         True if the datasource is reachable and the credentials are valid.
12250        '''
12251        self.hostname = hostname if hostname is not None else ''
12252        '''
12253
12254        '''
12255        self.id = id if id is not None else ''
12256        '''
12257         Unique identifier of the Resource.
12258        '''
12259        self.name = name if name is not None else ''
12260        '''
12261         Unique human-readable name of the Resource.
12262        '''
12263        self.port = port if port is not None else 0
12264        '''
12265
12266        '''
12267        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12268        '''
12269
12270        '''
12271        self.port_override = port_override if port_override is not None else 0
12272        '''
12273
12274        '''
12275        self.private_key = private_key if private_key is not None else ''
12276        '''
12277
12278        '''
12279        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12280        '''
12281         ID of the secret store containing credentials for this resource, if any.
12282        '''
12283        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12284        '''
12285         Tags is a map of key, value pairs.
12286        '''
12287        self.username = username if username is not None else ''
12288        '''
12289
12290        '''
12291
12292    def __repr__(self):
12293        return '<sdm.SSHCustomerKey ' + \
12294            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12295            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12296            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12297            'healthy: ' + repr(self.healthy) + ' ' +\
12298            'hostname: ' + repr(self.hostname) + ' ' +\
12299            'id: ' + repr(self.id) + ' ' +\
12300            'name: ' + repr(self.name) + ' ' +\
12301            'port: ' + repr(self.port) + ' ' +\
12302            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12303            'port_override: ' + repr(self.port_override) + ' ' +\
12304            'private_key: ' + repr(self.private_key) + ' ' +\
12305            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12306            'tags: ' + repr(self.tags) + ' ' +\
12307            'username: ' + repr(self.username) + ' ' +\
12308            '>'
12309
12310    def to_dict(self):
12311        return {
12312            'allow_deprecated_key_exchanges':
12313            self.allow_deprecated_key_exchanges,
12314            'bind_interface': self.bind_interface,
12315            'egress_filter': self.egress_filter,
12316            'healthy': self.healthy,
12317            'hostname': self.hostname,
12318            'id': self.id,
12319            'name': self.name,
12320            'port': self.port,
12321            'port_forwarding': self.port_forwarding,
12322            'port_override': self.port_override,
12323            'private_key': self.private_key,
12324            'secret_store_id': self.secret_store_id,
12325            'tags': self.tags,
12326            'username': self.username,
12327        }
12328
12329    @classmethod
12330    def from_dict(cls, d):
12331        return cls(
12332            allow_deprecated_key_exchanges=d.get(
12333                'allow_deprecated_key_exchanges'),
12334            bind_interface=d.get('bind_interface'),
12335            egress_filter=d.get('egress_filter'),
12336            healthy=d.get('healthy'),
12337            hostname=d.get('hostname'),
12338            id=d.get('id'),
12339            name=d.get('name'),
12340            port=d.get('port'),
12341            port_forwarding=d.get('port_forwarding'),
12342            port_override=d.get('port_override'),
12343            private_key=d.get('private_key'),
12344            secret_store_id=d.get('secret_store_id'),
12345            tags=d.get('tags'),
12346            username=d.get('username'),
12347        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
12218    def __init__(
12219        self,
12220        allow_deprecated_key_exchanges=None,
12221        bind_interface=None,
12222        egress_filter=None,
12223        healthy=None,
12224        hostname=None,
12225        id=None,
12226        name=None,
12227        port=None,
12228        port_forwarding=None,
12229        port_override=None,
12230        private_key=None,
12231        secret_store_id=None,
12232        tags=None,
12233        username=None,
12234    ):
12235        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12236        '''
12237
12238        '''
12239        self.bind_interface = bind_interface if bind_interface is not None else ''
12240        '''
12241         Bind interface
12242        '''
12243        self.egress_filter = egress_filter if egress_filter is not None else ''
12244        '''
12245         A filter applied to the routing logic to pin datasource to nodes.
12246        '''
12247        self.healthy = healthy if healthy is not None else False
12248        '''
12249         True if the datasource is reachable and the credentials are valid.
12250        '''
12251        self.hostname = hostname if hostname is not None else ''
12252        '''
12253
12254        '''
12255        self.id = id if id is not None else ''
12256        '''
12257         Unique identifier of the Resource.
12258        '''
12259        self.name = name if name is not None else ''
12260        '''
12261         Unique human-readable name of the Resource.
12262        '''
12263        self.port = port if port is not None else 0
12264        '''
12265
12266        '''
12267        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12268        '''
12269
12270        '''
12271        self.port_override = port_override if port_override is not None else 0
12272        '''
12273
12274        '''
12275        self.private_key = private_key if private_key is not None else ''
12276        '''
12277
12278        '''
12279        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12280        '''
12281         ID of the secret store containing credentials for this resource, if any.
12282        '''
12283        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12284        '''
12285         Tags is a map of key, value pairs.
12286        '''
12287        self.username = username if username is not None else ''
12288        '''
12289
12290        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12310    def to_dict(self):
12311        return {
12312            'allow_deprecated_key_exchanges':
12313            self.allow_deprecated_key_exchanges,
12314            'bind_interface': self.bind_interface,
12315            'egress_filter': self.egress_filter,
12316            'healthy': self.healthy,
12317            'hostname': self.hostname,
12318            'id': self.id,
12319            'name': self.name,
12320            'port': self.port,
12321            'port_forwarding': self.port_forwarding,
12322            'port_override': self.port_override,
12323            'private_key': self.private_key,
12324            'secret_store_id': self.secret_store_id,
12325            'tags': self.tags,
12326            'username': self.username,
12327        }
@classmethod
def from_dict(cls, d)
12329    @classmethod
12330    def from_dict(cls, d):
12331        return cls(
12332            allow_deprecated_key_exchanges=d.get(
12333                'allow_deprecated_key_exchanges'),
12334            bind_interface=d.get('bind_interface'),
12335            egress_filter=d.get('egress_filter'),
12336            healthy=d.get('healthy'),
12337            hostname=d.get('hostname'),
12338            id=d.get('id'),
12339            name=d.get('name'),
12340            port=d.get('port'),
12341            port_forwarding=d.get('port_forwarding'),
12342            port_override=d.get('port_override'),
12343            private_key=d.get('private_key'),
12344            secret_store_id=d.get('secret_store_id'),
12345            tags=d.get('tags'),
12346            username=d.get('username'),
12347        )
class SecretStoreCreateResponse:
12350class SecretStoreCreateResponse:
12351    '''
12352     SecretStoreCreateResponse reports how the SecretStores were created in the system.
12353    '''
12354    __slots__ = [
12355        'meta',
12356        'rate_limit',
12357        'secret_store',
12358    ]
12359
12360    def __init__(
12361        self,
12362        meta=None,
12363        rate_limit=None,
12364        secret_store=None,
12365    ):
12366        self.meta = meta if meta is not None else None
12367        '''
12368         Reserved for future use.
12369        '''
12370        self.rate_limit = rate_limit if rate_limit is not None else None
12371        '''
12372         Rate limit information.
12373        '''
12374        self.secret_store = secret_store if secret_store is not None else None
12375        '''
12376         The created SecretStore.
12377        '''
12378
12379    def __repr__(self):
12380        return '<sdm.SecretStoreCreateResponse ' + \
12381            'meta: ' + repr(self.meta) + ' ' +\
12382            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12383            'secret_store: ' + repr(self.secret_store) + ' ' +\
12384            '>'
12385
12386    def to_dict(self):
12387        return {
12388            'meta': self.meta,
12389            'rate_limit': self.rate_limit,
12390            'secret_store': self.secret_store,
12391        }
12392
12393    @classmethod
12394    def from_dict(cls, d):
12395        return cls(
12396            meta=d.get('meta'),
12397            rate_limit=d.get('rate_limit'),
12398            secret_store=d.get('secret_store'),
12399        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
12360    def __init__(
12361        self,
12362        meta=None,
12363        rate_limit=None,
12364        secret_store=None,
12365    ):
12366        self.meta = meta if meta is not None else None
12367        '''
12368         Reserved for future use.
12369        '''
12370        self.rate_limit = rate_limit if rate_limit is not None else None
12371        '''
12372         Rate limit information.
12373        '''
12374        self.secret_store = secret_store if secret_store is not None else None
12375        '''
12376         The created SecretStore.
12377        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
12386    def to_dict(self):
12387        return {
12388            'meta': self.meta,
12389            'rate_limit': self.rate_limit,
12390            'secret_store': self.secret_store,
12391        }
@classmethod
def from_dict(cls, d)
12393    @classmethod
12394    def from_dict(cls, d):
12395        return cls(
12396            meta=d.get('meta'),
12397            rate_limit=d.get('rate_limit'),
12398            secret_store=d.get('secret_store'),
12399        )
class SecretStoreDeleteResponse:
12402class SecretStoreDeleteResponse:
12403    '''
12404     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
12405    '''
12406    __slots__ = [
12407        'meta',
12408        'rate_limit',
12409    ]
12410
12411    def __init__(
12412        self,
12413        meta=None,
12414        rate_limit=None,
12415    ):
12416        self.meta = meta if meta is not None else None
12417        '''
12418         Reserved for future use.
12419        '''
12420        self.rate_limit = rate_limit if rate_limit is not None else None
12421        '''
12422         Rate limit information.
12423        '''
12424
12425    def __repr__(self):
12426        return '<sdm.SecretStoreDeleteResponse ' + \
12427            'meta: ' + repr(self.meta) + ' ' +\
12428            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12429            '>'
12430
12431    def to_dict(self):
12432        return {
12433            'meta': self.meta,
12434            'rate_limit': self.rate_limit,
12435        }
12436
12437    @classmethod
12438    def from_dict(cls, d):
12439        return cls(
12440            meta=d.get('meta'),
12441            rate_limit=d.get('rate_limit'),
12442        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
12411    def __init__(
12412        self,
12413        meta=None,
12414        rate_limit=None,
12415    ):
12416        self.meta = meta if meta is not None else None
12417        '''
12418         Reserved for future use.
12419        '''
12420        self.rate_limit = rate_limit if rate_limit is not None else None
12421        '''
12422         Rate limit information.
12423        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
12431    def to_dict(self):
12432        return {
12433            'meta': self.meta,
12434            'rate_limit': self.rate_limit,
12435        }
@classmethod
def from_dict(cls, d)
12437    @classmethod
12438    def from_dict(cls, d):
12439        return cls(
12440            meta=d.get('meta'),
12441            rate_limit=d.get('rate_limit'),
12442        )
class SecretStoreGetResponse:
12445class SecretStoreGetResponse:
12446    '''
12447     SecretStoreGetResponse returns a requested SecretStore.
12448    '''
12449    __slots__ = [
12450        'meta',
12451        'rate_limit',
12452        'secret_store',
12453    ]
12454
12455    def __init__(
12456        self,
12457        meta=None,
12458        rate_limit=None,
12459        secret_store=None,
12460    ):
12461        self.meta = meta if meta is not None else None
12462        '''
12463         Reserved for future use.
12464        '''
12465        self.rate_limit = rate_limit if rate_limit is not None else None
12466        '''
12467         Rate limit information.
12468        '''
12469        self.secret_store = secret_store if secret_store is not None else None
12470        '''
12471         The requested SecretStore.
12472        '''
12473
12474    def __repr__(self):
12475        return '<sdm.SecretStoreGetResponse ' + \
12476            'meta: ' + repr(self.meta) + ' ' +\
12477            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12478            'secret_store: ' + repr(self.secret_store) + ' ' +\
12479            '>'
12480
12481    def to_dict(self):
12482        return {
12483            'meta': self.meta,
12484            'rate_limit': self.rate_limit,
12485            'secret_store': self.secret_store,
12486        }
12487
12488    @classmethod
12489    def from_dict(cls, d):
12490        return cls(
12491            meta=d.get('meta'),
12492            rate_limit=d.get('rate_limit'),
12493            secret_store=d.get('secret_store'),
12494        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
12455    def __init__(
12456        self,
12457        meta=None,
12458        rate_limit=None,
12459        secret_store=None,
12460    ):
12461        self.meta = meta if meta is not None else None
12462        '''
12463         Reserved for future use.
12464        '''
12465        self.rate_limit = rate_limit if rate_limit is not None else None
12466        '''
12467         Rate limit information.
12468        '''
12469        self.secret_store = secret_store if secret_store is not None else None
12470        '''
12471         The requested SecretStore.
12472        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
12481    def to_dict(self):
12482        return {
12483            'meta': self.meta,
12484            'rate_limit': self.rate_limit,
12485            'secret_store': self.secret_store,
12486        }
@classmethod
def from_dict(cls, d)
12488    @classmethod
12489    def from_dict(cls, d):
12490        return cls(
12491            meta=d.get('meta'),
12492            rate_limit=d.get('rate_limit'),
12493            secret_store=d.get('secret_store'),
12494        )
class SecretStoreUpdateResponse:
12497class SecretStoreUpdateResponse:
12498    '''
12499     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12500     a SecretStoreUpdateRequest.
12501    '''
12502    __slots__ = [
12503        'meta',
12504        'rate_limit',
12505        'secret_store',
12506    ]
12507
12508    def __init__(
12509        self,
12510        meta=None,
12511        rate_limit=None,
12512        secret_store=None,
12513    ):
12514        self.meta = meta if meta is not None else None
12515        '''
12516         Reserved for future use.
12517        '''
12518        self.rate_limit = rate_limit if rate_limit is not None else None
12519        '''
12520         Rate limit information.
12521        '''
12522        self.secret_store = secret_store if secret_store is not None else None
12523        '''
12524         The updated SecretStore.
12525        '''
12526
12527    def __repr__(self):
12528        return '<sdm.SecretStoreUpdateResponse ' + \
12529            'meta: ' + repr(self.meta) + ' ' +\
12530            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12531            'secret_store: ' + repr(self.secret_store) + ' ' +\
12532            '>'
12533
12534    def to_dict(self):
12535        return {
12536            'meta': self.meta,
12537            'rate_limit': self.rate_limit,
12538            'secret_store': self.secret_store,
12539        }
12540
12541    @classmethod
12542    def from_dict(cls, d):
12543        return cls(
12544            meta=d.get('meta'),
12545            rate_limit=d.get('rate_limit'),
12546            secret_store=d.get('secret_store'),
12547        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
12508    def __init__(
12509        self,
12510        meta=None,
12511        rate_limit=None,
12512        secret_store=None,
12513    ):
12514        self.meta = meta if meta is not None else None
12515        '''
12516         Reserved for future use.
12517        '''
12518        self.rate_limit = rate_limit if rate_limit is not None else None
12519        '''
12520         Rate limit information.
12521        '''
12522        self.secret_store = secret_store if secret_store is not None else None
12523        '''
12524         The updated SecretStore.
12525        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
12534    def to_dict(self):
12535        return {
12536            'meta': self.meta,
12537            'rate_limit': self.rate_limit,
12538            'secret_store': self.secret_store,
12539        }
@classmethod
def from_dict(cls, d)
12541    @classmethod
12542    def from_dict(cls, d):
12543        return cls(
12544            meta=d.get('meta'),
12545            rate_limit=d.get('rate_limit'),
12546            secret_store=d.get('secret_store'),
12547        )
class Service:
12550class Service:
12551    '''
12552     A Service is a service account that can connect to resources they are granted
12553     directly, or granted via roles. Services are typically automated jobs.
12554    '''
12555    __slots__ = [
12556        'id',
12557        'name',
12558        'suspended',
12559        'tags',
12560    ]
12561
12562    def __init__(
12563        self,
12564        id=None,
12565        name=None,
12566        suspended=None,
12567        tags=None,
12568    ):
12569        self.id = id if id is not None else ''
12570        '''
12571         Unique identifier of the Service.
12572        '''
12573        self.name = name if name is not None else ''
12574        '''
12575         Unique human-readable name of the Service.
12576        '''
12577        self.suspended = suspended if suspended is not None else False
12578        '''
12579         The Service's suspended state.
12580        '''
12581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12582        '''
12583         Tags is a map of key, value pairs.
12584        '''
12585
12586    def __repr__(self):
12587        return '<sdm.Service ' + \
12588            'id: ' + repr(self.id) + ' ' +\
12589            'name: ' + repr(self.name) + ' ' +\
12590            'suspended: ' + repr(self.suspended) + ' ' +\
12591            'tags: ' + repr(self.tags) + ' ' +\
12592            '>'
12593
12594    def to_dict(self):
12595        return {
12596            'id': self.id,
12597            'name': self.name,
12598            'suspended': self.suspended,
12599            'tags': self.tags,
12600        }
12601
12602    @classmethod
12603    def from_dict(cls, d):
12604        return cls(
12605            id=d.get('id'),
12606            name=d.get('name'),
12607            suspended=d.get('suspended'),
12608            tags=d.get('tags'),
12609        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
12562    def __init__(
12563        self,
12564        id=None,
12565        name=None,
12566        suspended=None,
12567        tags=None,
12568    ):
12569        self.id = id if id is not None else ''
12570        '''
12571         Unique identifier of the Service.
12572        '''
12573        self.name = name if name is not None else ''
12574        '''
12575         Unique human-readable name of the Service.
12576        '''
12577        self.suspended = suspended if suspended is not None else False
12578        '''
12579         The Service's suspended state.
12580        '''
12581        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12582        '''
12583         Tags is a map of key, value pairs.
12584        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12594    def to_dict(self):
12595        return {
12596            'id': self.id,
12597            'name': self.name,
12598            'suspended': self.suspended,
12599            'tags': self.tags,
12600        }
@classmethod
def from_dict(cls, d)
12602    @classmethod
12603    def from_dict(cls, d):
12604        return cls(
12605            id=d.get('id'),
12606            name=d.get('name'),
12607            suspended=d.get('suspended'),
12608            tags=d.get('tags'),
12609        )
class SingleStore:
12612class SingleStore:
12613    '''
12614
12615    '''
12616    __slots__ = [
12617        'bind_interface',
12618        'database',
12619        'egress_filter',
12620        'healthy',
12621        'hostname',
12622        'id',
12623        'name',
12624        'password',
12625        'port',
12626        'port_override',
12627        'secret_store_id',
12628        'tags',
12629        'username',
12630    ]
12631
12632    def __init__(
12633        self,
12634        bind_interface=None,
12635        database=None,
12636        egress_filter=None,
12637        healthy=None,
12638        hostname=None,
12639        id=None,
12640        name=None,
12641        password=None,
12642        port=None,
12643        port_override=None,
12644        secret_store_id=None,
12645        tags=None,
12646        username=None,
12647    ):
12648        self.bind_interface = bind_interface if bind_interface is not None else ''
12649        '''
12650         Bind interface
12651        '''
12652        self.database = database if database is not None else ''
12653        '''
12654
12655        '''
12656        self.egress_filter = egress_filter if egress_filter is not None else ''
12657        '''
12658         A filter applied to the routing logic to pin datasource to nodes.
12659        '''
12660        self.healthy = healthy if healthy is not None else False
12661        '''
12662         True if the datasource is reachable and the credentials are valid.
12663        '''
12664        self.hostname = hostname if hostname is not None else ''
12665        '''
12666
12667        '''
12668        self.id = id if id is not None else ''
12669        '''
12670         Unique identifier of the Resource.
12671        '''
12672        self.name = name if name is not None else ''
12673        '''
12674         Unique human-readable name of the Resource.
12675        '''
12676        self.password = password if password is not None else ''
12677        '''
12678
12679        '''
12680        self.port = port if port is not None else 0
12681        '''
12682
12683        '''
12684        self.port_override = port_override if port_override is not None else 0
12685        '''
12686
12687        '''
12688        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12689        '''
12690         ID of the secret store containing credentials for this resource, if any.
12691        '''
12692        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12693        '''
12694         Tags is a map of key, value pairs.
12695        '''
12696        self.username = username if username is not None else ''
12697        '''
12698
12699        '''
12700
12701    def __repr__(self):
12702        return '<sdm.SingleStore ' + \
12703            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12704            'database: ' + repr(self.database) + ' ' +\
12705            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12706            'healthy: ' + repr(self.healthy) + ' ' +\
12707            'hostname: ' + repr(self.hostname) + ' ' +\
12708            'id: ' + repr(self.id) + ' ' +\
12709            'name: ' + repr(self.name) + ' ' +\
12710            'password: ' + repr(self.password) + ' ' +\
12711            'port: ' + repr(self.port) + ' ' +\
12712            'port_override: ' + repr(self.port_override) + ' ' +\
12713            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12714            'tags: ' + repr(self.tags) + ' ' +\
12715            'username: ' + repr(self.username) + ' ' +\
12716            '>'
12717
12718    def to_dict(self):
12719        return {
12720            'bind_interface': self.bind_interface,
12721            'database': self.database,
12722            'egress_filter': self.egress_filter,
12723            'healthy': self.healthy,
12724            'hostname': self.hostname,
12725            'id': self.id,
12726            'name': self.name,
12727            'password': self.password,
12728            'port': self.port,
12729            'port_override': self.port_override,
12730            'secret_store_id': self.secret_store_id,
12731            'tags': self.tags,
12732            'username': self.username,
12733        }
12734
12735    @classmethod
12736    def from_dict(cls, d):
12737        return cls(
12738            bind_interface=d.get('bind_interface'),
12739            database=d.get('database'),
12740            egress_filter=d.get('egress_filter'),
12741            healthy=d.get('healthy'),
12742            hostname=d.get('hostname'),
12743            id=d.get('id'),
12744            name=d.get('name'),
12745            password=d.get('password'),
12746            port=d.get('port'),
12747            port_override=d.get('port_override'),
12748            secret_store_id=d.get('secret_store_id'),
12749            tags=d.get('tags'),
12750            username=d.get('username'),
12751        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12632    def __init__(
12633        self,
12634        bind_interface=None,
12635        database=None,
12636        egress_filter=None,
12637        healthy=None,
12638        hostname=None,
12639        id=None,
12640        name=None,
12641        password=None,
12642        port=None,
12643        port_override=None,
12644        secret_store_id=None,
12645        tags=None,
12646        username=None,
12647    ):
12648        self.bind_interface = bind_interface if bind_interface is not None else ''
12649        '''
12650         Bind interface
12651        '''
12652        self.database = database if database is not None else ''
12653        '''
12654
12655        '''
12656        self.egress_filter = egress_filter if egress_filter is not None else ''
12657        '''
12658         A filter applied to the routing logic to pin datasource to nodes.
12659        '''
12660        self.healthy = healthy if healthy is not None else False
12661        '''
12662         True if the datasource is reachable and the credentials are valid.
12663        '''
12664        self.hostname = hostname if hostname is not None else ''
12665        '''
12666
12667        '''
12668        self.id = id if id is not None else ''
12669        '''
12670         Unique identifier of the Resource.
12671        '''
12672        self.name = name if name is not None else ''
12673        '''
12674         Unique human-readable name of the Resource.
12675        '''
12676        self.password = password if password is not None else ''
12677        '''
12678
12679        '''
12680        self.port = port if port is not None else 0
12681        '''
12682
12683        '''
12684        self.port_override = port_override if port_override is not None else 0
12685        '''
12686
12687        '''
12688        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12689        '''
12690         ID of the secret store containing credentials for this resource, if any.
12691        '''
12692        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12693        '''
12694         Tags is a map of key, value pairs.
12695        '''
12696        self.username = username if username is not None else ''
12697        '''
12698
12699        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12718    def to_dict(self):
12719        return {
12720            'bind_interface': self.bind_interface,
12721            'database': self.database,
12722            'egress_filter': self.egress_filter,
12723            'healthy': self.healthy,
12724            'hostname': self.hostname,
12725            'id': self.id,
12726            'name': self.name,
12727            'password': self.password,
12728            'port': self.port,
12729            'port_override': self.port_override,
12730            'secret_store_id': self.secret_store_id,
12731            'tags': self.tags,
12732            'username': self.username,
12733        }
@classmethod
def from_dict(cls, d)
12735    @classmethod
12736    def from_dict(cls, d):
12737        return cls(
12738            bind_interface=d.get('bind_interface'),
12739            database=d.get('database'),
12740            egress_filter=d.get('egress_filter'),
12741            healthy=d.get('healthy'),
12742            hostname=d.get('hostname'),
12743            id=d.get('id'),
12744            name=d.get('name'),
12745            password=d.get('password'),
12746            port=d.get('port'),
12747            port_override=d.get('port_override'),
12748            secret_store_id=d.get('secret_store_id'),
12749            tags=d.get('tags'),
12750            username=d.get('username'),
12751        )
class Snowflake:
12754class Snowflake:
12755    '''
12756
12757    '''
12758    __slots__ = [
12759        'bind_interface',
12760        'database',
12761        'egress_filter',
12762        'healthy',
12763        'hostname',
12764        'id',
12765        'name',
12766        'password',
12767        'port_override',
12768        'schema',
12769        'secret_store_id',
12770        'tags',
12771        'username',
12772    ]
12773
12774    def __init__(
12775        self,
12776        bind_interface=None,
12777        database=None,
12778        egress_filter=None,
12779        healthy=None,
12780        hostname=None,
12781        id=None,
12782        name=None,
12783        password=None,
12784        port_override=None,
12785        schema=None,
12786        secret_store_id=None,
12787        tags=None,
12788        username=None,
12789    ):
12790        self.bind_interface = bind_interface if bind_interface is not None else ''
12791        '''
12792         Bind interface
12793        '''
12794        self.database = database if database is not None else ''
12795        '''
12796
12797        '''
12798        self.egress_filter = egress_filter if egress_filter is not None else ''
12799        '''
12800         A filter applied to the routing logic to pin datasource to nodes.
12801        '''
12802        self.healthy = healthy if healthy is not None else False
12803        '''
12804         True if the datasource is reachable and the credentials are valid.
12805        '''
12806        self.hostname = hostname if hostname is not None else ''
12807        '''
12808
12809        '''
12810        self.id = id if id is not None else ''
12811        '''
12812         Unique identifier of the Resource.
12813        '''
12814        self.name = name if name is not None else ''
12815        '''
12816         Unique human-readable name of the Resource.
12817        '''
12818        self.password = password if password is not None else ''
12819        '''
12820
12821        '''
12822        self.port_override = port_override if port_override is not None else 0
12823        '''
12824
12825        '''
12826        self.schema = schema if schema is not None else ''
12827        '''
12828
12829        '''
12830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12831        '''
12832         ID of the secret store containing credentials for this resource, if any.
12833        '''
12834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12835        '''
12836         Tags is a map of key, value pairs.
12837        '''
12838        self.username = username if username is not None else ''
12839        '''
12840
12841        '''
12842
12843    def __repr__(self):
12844        return '<sdm.Snowflake ' + \
12845            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12846            'database: ' + repr(self.database) + ' ' +\
12847            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12848            'healthy: ' + repr(self.healthy) + ' ' +\
12849            'hostname: ' + repr(self.hostname) + ' ' +\
12850            'id: ' + repr(self.id) + ' ' +\
12851            'name: ' + repr(self.name) + ' ' +\
12852            'password: ' + repr(self.password) + ' ' +\
12853            'port_override: ' + repr(self.port_override) + ' ' +\
12854            'schema: ' + repr(self.schema) + ' ' +\
12855            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12856            'tags: ' + repr(self.tags) + ' ' +\
12857            'username: ' + repr(self.username) + ' ' +\
12858            '>'
12859
12860    def to_dict(self):
12861        return {
12862            'bind_interface': self.bind_interface,
12863            'database': self.database,
12864            'egress_filter': self.egress_filter,
12865            'healthy': self.healthy,
12866            'hostname': self.hostname,
12867            'id': self.id,
12868            'name': self.name,
12869            'password': self.password,
12870            'port_override': self.port_override,
12871            'schema': self.schema,
12872            'secret_store_id': self.secret_store_id,
12873            'tags': self.tags,
12874            'username': self.username,
12875        }
12876
12877    @classmethod
12878    def from_dict(cls, d):
12879        return cls(
12880            bind_interface=d.get('bind_interface'),
12881            database=d.get('database'),
12882            egress_filter=d.get('egress_filter'),
12883            healthy=d.get('healthy'),
12884            hostname=d.get('hostname'),
12885            id=d.get('id'),
12886            name=d.get('name'),
12887            password=d.get('password'),
12888            port_override=d.get('port_override'),
12889            schema=d.get('schema'),
12890            secret_store_id=d.get('secret_store_id'),
12891            tags=d.get('tags'),
12892            username=d.get('username'),
12893        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
12774    def __init__(
12775        self,
12776        bind_interface=None,
12777        database=None,
12778        egress_filter=None,
12779        healthy=None,
12780        hostname=None,
12781        id=None,
12782        name=None,
12783        password=None,
12784        port_override=None,
12785        schema=None,
12786        secret_store_id=None,
12787        tags=None,
12788        username=None,
12789    ):
12790        self.bind_interface = bind_interface if bind_interface is not None else ''
12791        '''
12792         Bind interface
12793        '''
12794        self.database = database if database is not None else ''
12795        '''
12796
12797        '''
12798        self.egress_filter = egress_filter if egress_filter is not None else ''
12799        '''
12800         A filter applied to the routing logic to pin datasource to nodes.
12801        '''
12802        self.healthy = healthy if healthy is not None else False
12803        '''
12804         True if the datasource is reachable and the credentials are valid.
12805        '''
12806        self.hostname = hostname if hostname is not None else ''
12807        '''
12808
12809        '''
12810        self.id = id if id is not None else ''
12811        '''
12812         Unique identifier of the Resource.
12813        '''
12814        self.name = name if name is not None else ''
12815        '''
12816         Unique human-readable name of the Resource.
12817        '''
12818        self.password = password if password is not None else ''
12819        '''
12820
12821        '''
12822        self.port_override = port_override if port_override is not None else 0
12823        '''
12824
12825        '''
12826        self.schema = schema if schema is not None else ''
12827        '''
12828
12829        '''
12830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12831        '''
12832         ID of the secret store containing credentials for this resource, if any.
12833        '''
12834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12835        '''
12836         Tags is a map of key, value pairs.
12837        '''
12838        self.username = username if username is not None else ''
12839        '''
12840
12841        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12860    def to_dict(self):
12861        return {
12862            'bind_interface': self.bind_interface,
12863            'database': self.database,
12864            'egress_filter': self.egress_filter,
12865            'healthy': self.healthy,
12866            'hostname': self.hostname,
12867            'id': self.id,
12868            'name': self.name,
12869            'password': self.password,
12870            'port_override': self.port_override,
12871            'schema': self.schema,
12872            'secret_store_id': self.secret_store_id,
12873            'tags': self.tags,
12874            'username': self.username,
12875        }
@classmethod
def from_dict(cls, d)
12877    @classmethod
12878    def from_dict(cls, d):
12879        return cls(
12880            bind_interface=d.get('bind_interface'),
12881            database=d.get('database'),
12882            egress_filter=d.get('egress_filter'),
12883            healthy=d.get('healthy'),
12884            hostname=d.get('hostname'),
12885            id=d.get('id'),
12886            name=d.get('name'),
12887            password=d.get('password'),
12888            port_override=d.get('port_override'),
12889            schema=d.get('schema'),
12890            secret_store_id=d.get('secret_store_id'),
12891            tags=d.get('tags'),
12892            username=d.get('username'),
12893        )
class Sybase:
12896class Sybase:
12897    '''
12898
12899    '''
12900    __slots__ = [
12901        'bind_interface',
12902        'egress_filter',
12903        'healthy',
12904        'hostname',
12905        'id',
12906        'name',
12907        'password',
12908        'port',
12909        'port_override',
12910        'secret_store_id',
12911        'tags',
12912        'username',
12913    ]
12914
12915    def __init__(
12916        self,
12917        bind_interface=None,
12918        egress_filter=None,
12919        healthy=None,
12920        hostname=None,
12921        id=None,
12922        name=None,
12923        password=None,
12924        port=None,
12925        port_override=None,
12926        secret_store_id=None,
12927        tags=None,
12928        username=None,
12929    ):
12930        self.bind_interface = bind_interface if bind_interface is not None else ''
12931        '''
12932         Bind interface
12933        '''
12934        self.egress_filter = egress_filter if egress_filter is not None else ''
12935        '''
12936         A filter applied to the routing logic to pin datasource to nodes.
12937        '''
12938        self.healthy = healthy if healthy is not None else False
12939        '''
12940         True if the datasource is reachable and the credentials are valid.
12941        '''
12942        self.hostname = hostname if hostname is not None else ''
12943        '''
12944
12945        '''
12946        self.id = id if id is not None else ''
12947        '''
12948         Unique identifier of the Resource.
12949        '''
12950        self.name = name if name is not None else ''
12951        '''
12952         Unique human-readable name of the Resource.
12953        '''
12954        self.password = password if password is not None else ''
12955        '''
12956
12957        '''
12958        self.port = port if port is not None else 0
12959        '''
12960
12961        '''
12962        self.port_override = port_override if port_override is not None else 0
12963        '''
12964
12965        '''
12966        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12967        '''
12968         ID of the secret store containing credentials for this resource, if any.
12969        '''
12970        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12971        '''
12972         Tags is a map of key, value pairs.
12973        '''
12974        self.username = username if username is not None else ''
12975        '''
12976
12977        '''
12978
12979    def __repr__(self):
12980        return '<sdm.Sybase ' + \
12981            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12982            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12983            'healthy: ' + repr(self.healthy) + ' ' +\
12984            'hostname: ' + repr(self.hostname) + ' ' +\
12985            'id: ' + repr(self.id) + ' ' +\
12986            'name: ' + repr(self.name) + ' ' +\
12987            'password: ' + repr(self.password) + ' ' +\
12988            'port: ' + repr(self.port) + ' ' +\
12989            'port_override: ' + repr(self.port_override) + ' ' +\
12990            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12991            'tags: ' + repr(self.tags) + ' ' +\
12992            'username: ' + repr(self.username) + ' ' +\
12993            '>'
12994
12995    def to_dict(self):
12996        return {
12997            'bind_interface': self.bind_interface,
12998            'egress_filter': self.egress_filter,
12999            'healthy': self.healthy,
13000            'hostname': self.hostname,
13001            'id': self.id,
13002            'name': self.name,
13003            'password': self.password,
13004            'port': self.port,
13005            'port_override': self.port_override,
13006            'secret_store_id': self.secret_store_id,
13007            'tags': self.tags,
13008            'username': self.username,
13009        }
13010
13011    @classmethod
13012    def from_dict(cls, d):
13013        return cls(
13014            bind_interface=d.get('bind_interface'),
13015            egress_filter=d.get('egress_filter'),
13016            healthy=d.get('healthy'),
13017            hostname=d.get('hostname'),
13018            id=d.get('id'),
13019            name=d.get('name'),
13020            password=d.get('password'),
13021            port=d.get('port'),
13022            port_override=d.get('port_override'),
13023            secret_store_id=d.get('secret_store_id'),
13024            tags=d.get('tags'),
13025            username=d.get('username'),
13026        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12915    def __init__(
12916        self,
12917        bind_interface=None,
12918        egress_filter=None,
12919        healthy=None,
12920        hostname=None,
12921        id=None,
12922        name=None,
12923        password=None,
12924        port=None,
12925        port_override=None,
12926        secret_store_id=None,
12927        tags=None,
12928        username=None,
12929    ):
12930        self.bind_interface = bind_interface if bind_interface is not None else ''
12931        '''
12932         Bind interface
12933        '''
12934        self.egress_filter = egress_filter if egress_filter is not None else ''
12935        '''
12936         A filter applied to the routing logic to pin datasource to nodes.
12937        '''
12938        self.healthy = healthy if healthy is not None else False
12939        '''
12940         True if the datasource is reachable and the credentials are valid.
12941        '''
12942        self.hostname = hostname if hostname is not None else ''
12943        '''
12944
12945        '''
12946        self.id = id if id is not None else ''
12947        '''
12948         Unique identifier of the Resource.
12949        '''
12950        self.name = name if name is not None else ''
12951        '''
12952         Unique human-readable name of the Resource.
12953        '''
12954        self.password = password if password is not None else ''
12955        '''
12956
12957        '''
12958        self.port = port if port is not None else 0
12959        '''
12960
12961        '''
12962        self.port_override = port_override if port_override is not None else 0
12963        '''
12964
12965        '''
12966        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12967        '''
12968         ID of the secret store containing credentials for this resource, if any.
12969        '''
12970        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12971        '''
12972         Tags is a map of key, value pairs.
12973        '''
12974        self.username = username if username is not None else ''
12975        '''
12976
12977        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12995    def to_dict(self):
12996        return {
12997            'bind_interface': self.bind_interface,
12998            'egress_filter': self.egress_filter,
12999            'healthy': self.healthy,
13000            'hostname': self.hostname,
13001            'id': self.id,
13002            'name': self.name,
13003            'password': self.password,
13004            'port': self.port,
13005            'port_override': self.port_override,
13006            'secret_store_id': self.secret_store_id,
13007            'tags': self.tags,
13008            'username': self.username,
13009        }
@classmethod
def from_dict(cls, d)
13011    @classmethod
13012    def from_dict(cls, d):
13013        return cls(
13014            bind_interface=d.get('bind_interface'),
13015            egress_filter=d.get('egress_filter'),
13016            healthy=d.get('healthy'),
13017            hostname=d.get('hostname'),
13018            id=d.get('id'),
13019            name=d.get('name'),
13020            password=d.get('password'),
13021            port=d.get('port'),
13022            port_override=d.get('port_override'),
13023            secret_store_id=d.get('secret_store_id'),
13024            tags=d.get('tags'),
13025            username=d.get('username'),
13026        )
class SybaseIQ:
13029class SybaseIQ:
13030    '''
13031
13032    '''
13033    __slots__ = [
13034        'bind_interface',
13035        'egress_filter',
13036        'healthy',
13037        'hostname',
13038        'id',
13039        'name',
13040        'password',
13041        'port',
13042        'port_override',
13043        'secret_store_id',
13044        'tags',
13045        'username',
13046    ]
13047
13048    def __init__(
13049        self,
13050        bind_interface=None,
13051        egress_filter=None,
13052        healthy=None,
13053        hostname=None,
13054        id=None,
13055        name=None,
13056        password=None,
13057        port=None,
13058        port_override=None,
13059        secret_store_id=None,
13060        tags=None,
13061        username=None,
13062    ):
13063        self.bind_interface = bind_interface if bind_interface is not None else ''
13064        '''
13065         Bind interface
13066        '''
13067        self.egress_filter = egress_filter if egress_filter is not None else ''
13068        '''
13069         A filter applied to the routing logic to pin datasource to nodes.
13070        '''
13071        self.healthy = healthy if healthy is not None else False
13072        '''
13073         True if the datasource is reachable and the credentials are valid.
13074        '''
13075        self.hostname = hostname if hostname is not None else ''
13076        '''
13077
13078        '''
13079        self.id = id if id is not None else ''
13080        '''
13081         Unique identifier of the Resource.
13082        '''
13083        self.name = name if name is not None else ''
13084        '''
13085         Unique human-readable name of the Resource.
13086        '''
13087        self.password = password if password is not None else ''
13088        '''
13089
13090        '''
13091        self.port = port if port is not None else 0
13092        '''
13093
13094        '''
13095        self.port_override = port_override if port_override is not None else 0
13096        '''
13097
13098        '''
13099        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13100        '''
13101         ID of the secret store containing credentials for this resource, if any.
13102        '''
13103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13104        '''
13105         Tags is a map of key, value pairs.
13106        '''
13107        self.username = username if username is not None else ''
13108        '''
13109
13110        '''
13111
13112    def __repr__(self):
13113        return '<sdm.SybaseIQ ' + \
13114            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13115            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13116            'healthy: ' + repr(self.healthy) + ' ' +\
13117            'hostname: ' + repr(self.hostname) + ' ' +\
13118            'id: ' + repr(self.id) + ' ' +\
13119            'name: ' + repr(self.name) + ' ' +\
13120            'password: ' + repr(self.password) + ' ' +\
13121            'port: ' + repr(self.port) + ' ' +\
13122            'port_override: ' + repr(self.port_override) + ' ' +\
13123            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13124            'tags: ' + repr(self.tags) + ' ' +\
13125            'username: ' + repr(self.username) + ' ' +\
13126            '>'
13127
13128    def to_dict(self):
13129        return {
13130            'bind_interface': self.bind_interface,
13131            'egress_filter': self.egress_filter,
13132            'healthy': self.healthy,
13133            'hostname': self.hostname,
13134            'id': self.id,
13135            'name': self.name,
13136            'password': self.password,
13137            'port': self.port,
13138            'port_override': self.port_override,
13139            'secret_store_id': self.secret_store_id,
13140            'tags': self.tags,
13141            'username': self.username,
13142        }
13143
13144    @classmethod
13145    def from_dict(cls, d):
13146        return cls(
13147            bind_interface=d.get('bind_interface'),
13148            egress_filter=d.get('egress_filter'),
13149            healthy=d.get('healthy'),
13150            hostname=d.get('hostname'),
13151            id=d.get('id'),
13152            name=d.get('name'),
13153            password=d.get('password'),
13154            port=d.get('port'),
13155            port_override=d.get('port_override'),
13156            secret_store_id=d.get('secret_store_id'),
13157            tags=d.get('tags'),
13158            username=d.get('username'),
13159        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
13048    def __init__(
13049        self,
13050        bind_interface=None,
13051        egress_filter=None,
13052        healthy=None,
13053        hostname=None,
13054        id=None,
13055        name=None,
13056        password=None,
13057        port=None,
13058        port_override=None,
13059        secret_store_id=None,
13060        tags=None,
13061        username=None,
13062    ):
13063        self.bind_interface = bind_interface if bind_interface is not None else ''
13064        '''
13065         Bind interface
13066        '''
13067        self.egress_filter = egress_filter if egress_filter is not None else ''
13068        '''
13069         A filter applied to the routing logic to pin datasource to nodes.
13070        '''
13071        self.healthy = healthy if healthy is not None else False
13072        '''
13073         True if the datasource is reachable and the credentials are valid.
13074        '''
13075        self.hostname = hostname if hostname is not None else ''
13076        '''
13077
13078        '''
13079        self.id = id if id is not None else ''
13080        '''
13081         Unique identifier of the Resource.
13082        '''
13083        self.name = name if name is not None else ''
13084        '''
13085         Unique human-readable name of the Resource.
13086        '''
13087        self.password = password if password is not None else ''
13088        '''
13089
13090        '''
13091        self.port = port if port is not None else 0
13092        '''
13093
13094        '''
13095        self.port_override = port_override if port_override is not None else 0
13096        '''
13097
13098        '''
13099        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13100        '''
13101         ID of the secret store containing credentials for this resource, if any.
13102        '''
13103        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13104        '''
13105         Tags is a map of key, value pairs.
13106        '''
13107        self.username = username if username is not None else ''
13108        '''
13109
13110        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
13128    def to_dict(self):
13129        return {
13130            'bind_interface': self.bind_interface,
13131            'egress_filter': self.egress_filter,
13132            'healthy': self.healthy,
13133            'hostname': self.hostname,
13134            'id': self.id,
13135            'name': self.name,
13136            'password': self.password,
13137            'port': self.port,
13138            'port_override': self.port_override,
13139            'secret_store_id': self.secret_store_id,
13140            'tags': self.tags,
13141            'username': self.username,
13142        }
@classmethod
def from_dict(cls, d)
13144    @classmethod
13145    def from_dict(cls, d):
13146        return cls(
13147            bind_interface=d.get('bind_interface'),
13148            egress_filter=d.get('egress_filter'),
13149            healthy=d.get('healthy'),
13150            hostname=d.get('hostname'),
13151            id=d.get('id'),
13152            name=d.get('name'),
13153            password=d.get('password'),
13154            port=d.get('port'),
13155            port_override=d.get('port_override'),
13156            secret_store_id=d.get('secret_store_id'),
13157            tags=d.get('tags'),
13158            username=d.get('username'),
13159        )
class Tag:
13162class Tag:
13163    '''
13164
13165    '''
13166    __slots__ = [
13167        'name',
13168        'value',
13169    ]
13170
13171    def __init__(
13172        self,
13173        name=None,
13174        value=None,
13175    ):
13176        self.name = name if name is not None else ''
13177        '''
13178
13179        '''
13180        self.value = value if value is not None else ''
13181        '''
13182
13183        '''
13184
13185    def __repr__(self):
13186        return '<sdm.Tag ' + \
13187            'name: ' + repr(self.name) + ' ' +\
13188            'value: ' + repr(self.value) + ' ' +\
13189            '>'
13190
13191    def to_dict(self):
13192        return {
13193            'name': self.name,
13194            'value': self.value,
13195        }
13196
13197    @classmethod
13198    def from_dict(cls, d):
13199        return cls(
13200            name=d.get('name'),
13201            value=d.get('value'),
13202        )
Tag(name=None, value=None)
13171    def __init__(
13172        self,
13173        name=None,
13174        value=None,
13175    ):
13176        self.name = name if name is not None else ''
13177        '''
13178
13179        '''
13180        self.value = value if value is not None else ''
13181        '''
13182
13183        '''
name
value
def to_dict(self)
13191    def to_dict(self):
13192        return {
13193            'name': self.name,
13194            'value': self.value,
13195        }
@classmethod
def from_dict(cls, d)
13197    @classmethod
13198    def from_dict(cls, d):
13199        return cls(
13200            name=d.get('name'),
13201            value=d.get('value'),
13202        )
class Teradata:
13205class Teradata:
13206    '''
13207
13208    '''
13209    __slots__ = [
13210        'bind_interface',
13211        'egress_filter',
13212        'healthy',
13213        'hostname',
13214        'id',
13215        'name',
13216        'password',
13217        'port',
13218        'port_override',
13219        'secret_store_id',
13220        'tags',
13221        'username',
13222    ]
13223
13224    def __init__(
13225        self,
13226        bind_interface=None,
13227        egress_filter=None,
13228        healthy=None,
13229        hostname=None,
13230        id=None,
13231        name=None,
13232        password=None,
13233        port=None,
13234        port_override=None,
13235        secret_store_id=None,
13236        tags=None,
13237        username=None,
13238    ):
13239        self.bind_interface = bind_interface if bind_interface is not None else ''
13240        '''
13241         Bind interface
13242        '''
13243        self.egress_filter = egress_filter if egress_filter is not None else ''
13244        '''
13245         A filter applied to the routing logic to pin datasource to nodes.
13246        '''
13247        self.healthy = healthy if healthy is not None else False
13248        '''
13249         True if the datasource is reachable and the credentials are valid.
13250        '''
13251        self.hostname = hostname if hostname is not None else ''
13252        '''
13253
13254        '''
13255        self.id = id if id is not None else ''
13256        '''
13257         Unique identifier of the Resource.
13258        '''
13259        self.name = name if name is not None else ''
13260        '''
13261         Unique human-readable name of the Resource.
13262        '''
13263        self.password = password if password is not None else ''
13264        '''
13265
13266        '''
13267        self.port = port if port is not None else 0
13268        '''
13269
13270        '''
13271        self.port_override = port_override if port_override is not None else 0
13272        '''
13273
13274        '''
13275        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13276        '''
13277         ID of the secret store containing credentials for this resource, if any.
13278        '''
13279        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13280        '''
13281         Tags is a map of key, value pairs.
13282        '''
13283        self.username = username if username is not None else ''
13284        '''
13285
13286        '''
13287
13288    def __repr__(self):
13289        return '<sdm.Teradata ' + \
13290            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13291            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13292            'healthy: ' + repr(self.healthy) + ' ' +\
13293            'hostname: ' + repr(self.hostname) + ' ' +\
13294            'id: ' + repr(self.id) + ' ' +\
13295            'name: ' + repr(self.name) + ' ' +\
13296            'password: ' + repr(self.password) + ' ' +\
13297            'port: ' + repr(self.port) + ' ' +\
13298            'port_override: ' + repr(self.port_override) + ' ' +\
13299            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13300            'tags: ' + repr(self.tags) + ' ' +\
13301            'username: ' + repr(self.username) + ' ' +\
13302            '>'
13303
13304    def to_dict(self):
13305        return {
13306            'bind_interface': self.bind_interface,
13307            'egress_filter': self.egress_filter,
13308            'healthy': self.healthy,
13309            'hostname': self.hostname,
13310            'id': self.id,
13311            'name': self.name,
13312            'password': self.password,
13313            'port': self.port,
13314            'port_override': self.port_override,
13315            'secret_store_id': self.secret_store_id,
13316            'tags': self.tags,
13317            'username': self.username,
13318        }
13319
13320    @classmethod
13321    def from_dict(cls, d):
13322        return cls(
13323            bind_interface=d.get('bind_interface'),
13324            egress_filter=d.get('egress_filter'),
13325            healthy=d.get('healthy'),
13326            hostname=d.get('hostname'),
13327            id=d.get('id'),
13328            name=d.get('name'),
13329            password=d.get('password'),
13330            port=d.get('port'),
13331            port_override=d.get('port_override'),
13332            secret_store_id=d.get('secret_store_id'),
13333            tags=d.get('tags'),
13334            username=d.get('username'),
13335        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
13224    def __init__(
13225        self,
13226        bind_interface=None,
13227        egress_filter=None,
13228        healthy=None,
13229        hostname=None,
13230        id=None,
13231        name=None,
13232        password=None,
13233        port=None,
13234        port_override=None,
13235        secret_store_id=None,
13236        tags=None,
13237        username=None,
13238    ):
13239        self.bind_interface = bind_interface if bind_interface is not None else ''
13240        '''
13241         Bind interface
13242        '''
13243        self.egress_filter = egress_filter if egress_filter is not None else ''
13244        '''
13245         A filter applied to the routing logic to pin datasource to nodes.
13246        '''
13247        self.healthy = healthy if healthy is not None else False
13248        '''
13249         True if the datasource is reachable and the credentials are valid.
13250        '''
13251        self.hostname = hostname if hostname is not None else ''
13252        '''
13253
13254        '''
13255        self.id = id if id is not None else ''
13256        '''
13257         Unique identifier of the Resource.
13258        '''
13259        self.name = name if name is not None else ''
13260        '''
13261         Unique human-readable name of the Resource.
13262        '''
13263        self.password = password if password is not None else ''
13264        '''
13265
13266        '''
13267        self.port = port if port is not None else 0
13268        '''
13269
13270        '''
13271        self.port_override = port_override if port_override is not None else 0
13272        '''
13273
13274        '''
13275        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13276        '''
13277         ID of the secret store containing credentials for this resource, if any.
13278        '''
13279        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13280        '''
13281         Tags is a map of key, value pairs.
13282        '''
13283        self.username = username if username is not None else ''
13284        '''
13285
13286        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
13304    def to_dict(self):
13305        return {
13306            'bind_interface': self.bind_interface,
13307            'egress_filter': self.egress_filter,
13308            'healthy': self.healthy,
13309            'hostname': self.hostname,
13310            'id': self.id,
13311            'name': self.name,
13312            'password': self.password,
13313            'port': self.port,
13314            'port_override': self.port_override,
13315            'secret_store_id': self.secret_store_id,
13316            'tags': self.tags,
13317            'username': self.username,
13318        }
@classmethod
def from_dict(cls, d)
13320    @classmethod
13321    def from_dict(cls, d):
13322        return cls(
13323            bind_interface=d.get('bind_interface'),
13324            egress_filter=d.get('egress_filter'),
13325            healthy=d.get('healthy'),
13326            hostname=d.get('hostname'),
13327            id=d.get('id'),
13328            name=d.get('name'),
13329            password=d.get('password'),
13330            port=d.get('port'),
13331            port_override=d.get('port_override'),
13332            secret_store_id=d.get('secret_store_id'),
13333            tags=d.get('tags'),
13334            username=d.get('username'),
13335        )
class UpdateResponseMetadata:
13338class UpdateResponseMetadata:
13339    '''
13340     UpdateResponseMetadata is reserved for future use.
13341    '''
13342    __slots__ = []
13343
13344    def __init__(self, ):
13345        pass
13346
13347    def __repr__(self):
13348        return '<sdm.UpdateResponseMetadata ' + \
13349            '>'
13350
13351    def to_dict(self):
13352        return {}
13353
13354    @classmethod
13355    def from_dict(cls, d):
13356        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
13344    def __init__(self, ):
13345        pass
def to_dict(self)
13351    def to_dict(self):
13352        return {}
@classmethod
def from_dict(cls, d)
13354    @classmethod
13355    def from_dict(cls, d):
13356        return cls()
class User:
13359class User:
13360    '''
13361     A User can connect to resources they are granted directly, or granted
13362     via roles.
13363    '''
13364    __slots__ = [
13365        'email',
13366        'first_name',
13367        'id',
13368        'last_name',
13369        'suspended',
13370        'tags',
13371    ]
13372
13373    def __init__(
13374        self,
13375        email=None,
13376        first_name=None,
13377        id=None,
13378        last_name=None,
13379        suspended=None,
13380        tags=None,
13381    ):
13382        self.email = email if email is not None else ''
13383        '''
13384         The User's email address. Must be unique.
13385        '''
13386        self.first_name = first_name if first_name is not None else ''
13387        '''
13388         The User's first name.
13389        '''
13390        self.id = id if id is not None else ''
13391        '''
13392         Unique identifier of the User.
13393        '''
13394        self.last_name = last_name if last_name is not None else ''
13395        '''
13396         The User's last name.
13397        '''
13398        self.suspended = suspended if suspended is not None else False
13399        '''
13400         The User's suspended state.
13401        '''
13402        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13403        '''
13404         Tags is a map of key, value pairs.
13405        '''
13406
13407    def __repr__(self):
13408        return '<sdm.User ' + \
13409            'email: ' + repr(self.email) + ' ' +\
13410            'first_name: ' + repr(self.first_name) + ' ' +\
13411            'id: ' + repr(self.id) + ' ' +\
13412            'last_name: ' + repr(self.last_name) + ' ' +\
13413            'suspended: ' + repr(self.suspended) + ' ' +\
13414            'tags: ' + repr(self.tags) + ' ' +\
13415            '>'
13416
13417    def to_dict(self):
13418        return {
13419            'email': self.email,
13420            'first_name': self.first_name,
13421            'id': self.id,
13422            'last_name': self.last_name,
13423            'suspended': self.suspended,
13424            'tags': self.tags,
13425        }
13426
13427    @classmethod
13428    def from_dict(cls, d):
13429        return cls(
13430            email=d.get('email'),
13431            first_name=d.get('first_name'),
13432            id=d.get('id'),
13433            last_name=d.get('last_name'),
13434            suspended=d.get('suspended'),
13435            tags=d.get('tags'),
13436        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
13373    def __init__(
13374        self,
13375        email=None,
13376        first_name=None,
13377        id=None,
13378        last_name=None,
13379        suspended=None,
13380        tags=None,
13381    ):
13382        self.email = email if email is not None else ''
13383        '''
13384         The User's email address. Must be unique.
13385        '''
13386        self.first_name = first_name if first_name is not None else ''
13387        '''
13388         The User's first name.
13389        '''
13390        self.id = id if id is not None else ''
13391        '''
13392         Unique identifier of the User.
13393        '''
13394        self.last_name = last_name if last_name is not None else ''
13395        '''
13396         The User's last name.
13397        '''
13398        self.suspended = suspended if suspended is not None else False
13399        '''
13400         The User's suspended state.
13401        '''
13402        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13403        '''
13404         Tags is a map of key, value pairs.
13405        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
13417    def to_dict(self):
13418        return {
13419            'email': self.email,
13420            'first_name': self.first_name,
13421            'id': self.id,
13422            'last_name': self.last_name,
13423            'suspended': self.suspended,
13424            'tags': self.tags,
13425        }
@classmethod
def from_dict(cls, d)
13427    @classmethod
13428    def from_dict(cls, d):
13429        return cls(
13430            email=d.get('email'),
13431            first_name=d.get('first_name'),
13432            id=d.get('id'),
13433            last_name=d.get('last_name'),
13434            suspended=d.get('suspended'),
13435            tags=d.get('tags'),
13436        )
class VaultAppRoleStore:
13439class VaultAppRoleStore:
13440    '''
13441
13442    '''
13443    __slots__ = [
13444        'id',
13445        'name',
13446        'namespace',
13447        'server_address',
13448        'tags',
13449    ]
13450
13451    def __init__(
13452        self,
13453        id=None,
13454        name=None,
13455        namespace=None,
13456        server_address=None,
13457        tags=None,
13458    ):
13459        self.id = id if id is not None else ''
13460        '''
13461         Unique identifier of the SecretStore.
13462        '''
13463        self.name = name if name is not None else ''
13464        '''
13465         Unique human-readable name of the SecretStore.
13466        '''
13467        self.namespace = namespace if namespace is not None else ''
13468        '''
13469
13470        '''
13471        self.server_address = server_address if server_address is not None else ''
13472        '''
13473
13474        '''
13475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13476        '''
13477         Tags is a map of key, value pairs.
13478        '''
13479
13480    def __repr__(self):
13481        return '<sdm.VaultAppRoleStore ' + \
13482            'id: ' + repr(self.id) + ' ' +\
13483            'name: ' + repr(self.name) + ' ' +\
13484            'namespace: ' + repr(self.namespace) + ' ' +\
13485            'server_address: ' + repr(self.server_address) + ' ' +\
13486            'tags: ' + repr(self.tags) + ' ' +\
13487            '>'
13488
13489    def to_dict(self):
13490        return {
13491            'id': self.id,
13492            'name': self.name,
13493            'namespace': self.namespace,
13494            'server_address': self.server_address,
13495            'tags': self.tags,
13496        }
13497
13498    @classmethod
13499    def from_dict(cls, d):
13500        return cls(
13501            id=d.get('id'),
13502            name=d.get('name'),
13503            namespace=d.get('namespace'),
13504            server_address=d.get('server_address'),
13505            tags=d.get('tags'),
13506        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13451    def __init__(
13452        self,
13453        id=None,
13454        name=None,
13455        namespace=None,
13456        server_address=None,
13457        tags=None,
13458    ):
13459        self.id = id if id is not None else ''
13460        '''
13461         Unique identifier of the SecretStore.
13462        '''
13463        self.name = name if name is not None else ''
13464        '''
13465         Unique human-readable name of the SecretStore.
13466        '''
13467        self.namespace = namespace if namespace is not None else ''
13468        '''
13469
13470        '''
13471        self.server_address = server_address if server_address is not None else ''
13472        '''
13473
13474        '''
13475        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13476        '''
13477         Tags is a map of key, value pairs.
13478        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13489    def to_dict(self):
13490        return {
13491            'id': self.id,
13492            'name': self.name,
13493            'namespace': self.namespace,
13494            'server_address': self.server_address,
13495            'tags': self.tags,
13496        }
@classmethod
def from_dict(cls, d)
13498    @classmethod
13499    def from_dict(cls, d):
13500        return cls(
13501            id=d.get('id'),
13502            name=d.get('name'),
13503            namespace=d.get('namespace'),
13504            server_address=d.get('server_address'),
13505            tags=d.get('tags'),
13506        )
class VaultTLSStore:
13509class VaultTLSStore:
13510    '''
13511
13512    '''
13513    __slots__ = [
13514        'ca_cert_path',
13515        'client_cert_path',
13516        'client_key_path',
13517        'id',
13518        'name',
13519        'namespace',
13520        'server_address',
13521        'tags',
13522    ]
13523
13524    def __init__(
13525        self,
13526        ca_cert_path=None,
13527        client_cert_path=None,
13528        client_key_path=None,
13529        id=None,
13530        name=None,
13531        namespace=None,
13532        server_address=None,
13533        tags=None,
13534    ):
13535        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13536        '''
13537
13538        '''
13539        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13540        '''
13541
13542        '''
13543        self.client_key_path = client_key_path if client_key_path is not None else ''
13544        '''
13545
13546        '''
13547        self.id = id if id is not None else ''
13548        '''
13549         Unique identifier of the SecretStore.
13550        '''
13551        self.name = name if name is not None else ''
13552        '''
13553         Unique human-readable name of the SecretStore.
13554        '''
13555        self.namespace = namespace if namespace is not None else ''
13556        '''
13557
13558        '''
13559        self.server_address = server_address if server_address is not None else ''
13560        '''
13561
13562        '''
13563        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13564        '''
13565         Tags is a map of key, value pairs.
13566        '''
13567
13568    def __repr__(self):
13569        return '<sdm.VaultTLSStore ' + \
13570            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13571            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13572            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13573            'id: ' + repr(self.id) + ' ' +\
13574            'name: ' + repr(self.name) + ' ' +\
13575            'namespace: ' + repr(self.namespace) + ' ' +\
13576            'server_address: ' + repr(self.server_address) + ' ' +\
13577            'tags: ' + repr(self.tags) + ' ' +\
13578            '>'
13579
13580    def to_dict(self):
13581        return {
13582            'ca_cert_path': self.ca_cert_path,
13583            'client_cert_path': self.client_cert_path,
13584            'client_key_path': self.client_key_path,
13585            'id': self.id,
13586            'name': self.name,
13587            'namespace': self.namespace,
13588            'server_address': self.server_address,
13589            'tags': self.tags,
13590        }
13591
13592    @classmethod
13593    def from_dict(cls, d):
13594        return cls(
13595            ca_cert_path=d.get('ca_cert_path'),
13596            client_cert_path=d.get('client_cert_path'),
13597            client_key_path=d.get('client_key_path'),
13598            id=d.get('id'),
13599            name=d.get('name'),
13600            namespace=d.get('namespace'),
13601            server_address=d.get('server_address'),
13602            tags=d.get('tags'),
13603        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
13524    def __init__(
13525        self,
13526        ca_cert_path=None,
13527        client_cert_path=None,
13528        client_key_path=None,
13529        id=None,
13530        name=None,
13531        namespace=None,
13532        server_address=None,
13533        tags=None,
13534    ):
13535        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13536        '''
13537
13538        '''
13539        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13540        '''
13541
13542        '''
13543        self.client_key_path = client_key_path if client_key_path is not None else ''
13544        '''
13545
13546        '''
13547        self.id = id if id is not None else ''
13548        '''
13549         Unique identifier of the SecretStore.
13550        '''
13551        self.name = name if name is not None else ''
13552        '''
13553         Unique human-readable name of the SecretStore.
13554        '''
13555        self.namespace = namespace if namespace is not None else ''
13556        '''
13557
13558        '''
13559        self.server_address = server_address if server_address is not None else ''
13560        '''
13561
13562        '''
13563        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13564        '''
13565         Tags is a map of key, value pairs.
13566        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13580    def to_dict(self):
13581        return {
13582            'ca_cert_path': self.ca_cert_path,
13583            'client_cert_path': self.client_cert_path,
13584            'client_key_path': self.client_key_path,
13585            'id': self.id,
13586            'name': self.name,
13587            'namespace': self.namespace,
13588            'server_address': self.server_address,
13589            'tags': self.tags,
13590        }
@classmethod
def from_dict(cls, d)
13592    @classmethod
13593    def from_dict(cls, d):
13594        return cls(
13595            ca_cert_path=d.get('ca_cert_path'),
13596            client_cert_path=d.get('client_cert_path'),
13597            client_key_path=d.get('client_key_path'),
13598            id=d.get('id'),
13599            name=d.get('name'),
13600            namespace=d.get('namespace'),
13601            server_address=d.get('server_address'),
13602            tags=d.get('tags'),
13603        )
class VaultTokenStore:
13606class VaultTokenStore:
13607    '''
13608
13609    '''
13610    __slots__ = [
13611        'id',
13612        'name',
13613        'namespace',
13614        'server_address',
13615        'tags',
13616    ]
13617
13618    def __init__(
13619        self,
13620        id=None,
13621        name=None,
13622        namespace=None,
13623        server_address=None,
13624        tags=None,
13625    ):
13626        self.id = id if id is not None else ''
13627        '''
13628         Unique identifier of the SecretStore.
13629        '''
13630        self.name = name if name is not None else ''
13631        '''
13632         Unique human-readable name of the SecretStore.
13633        '''
13634        self.namespace = namespace if namespace is not None else ''
13635        '''
13636
13637        '''
13638        self.server_address = server_address if server_address is not None else ''
13639        '''
13640
13641        '''
13642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13643        '''
13644         Tags is a map of key, value pairs.
13645        '''
13646
13647    def __repr__(self):
13648        return '<sdm.VaultTokenStore ' + \
13649            'id: ' + repr(self.id) + ' ' +\
13650            'name: ' + repr(self.name) + ' ' +\
13651            'namespace: ' + repr(self.namespace) + ' ' +\
13652            'server_address: ' + repr(self.server_address) + ' ' +\
13653            'tags: ' + repr(self.tags) + ' ' +\
13654            '>'
13655
13656    def to_dict(self):
13657        return {
13658            'id': self.id,
13659            'name': self.name,
13660            'namespace': self.namespace,
13661            'server_address': self.server_address,
13662            'tags': self.tags,
13663        }
13664
13665    @classmethod
13666    def from_dict(cls, d):
13667        return cls(
13668            id=d.get('id'),
13669            name=d.get('name'),
13670            namespace=d.get('namespace'),
13671            server_address=d.get('server_address'),
13672            tags=d.get('tags'),
13673        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13618    def __init__(
13619        self,
13620        id=None,
13621        name=None,
13622        namespace=None,
13623        server_address=None,
13624        tags=None,
13625    ):
13626        self.id = id if id is not None else ''
13627        '''
13628         Unique identifier of the SecretStore.
13629        '''
13630        self.name = name if name is not None else ''
13631        '''
13632         Unique human-readable name of the SecretStore.
13633        '''
13634        self.namespace = namespace if namespace is not None else ''
13635        '''
13636
13637        '''
13638        self.server_address = server_address if server_address is not None else ''
13639        '''
13640
13641        '''
13642        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13643        '''
13644         Tags is a map of key, value pairs.
13645        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13656    def to_dict(self):
13657        return {
13658            'id': self.id,
13659            'name': self.name,
13660            'namespace': self.namespace,
13661            'server_address': self.server_address,
13662            'tags': self.tags,
13663        }
@classmethod
def from_dict(cls, d)
13665    @classmethod
13666    def from_dict(cls, d):
13667        return cls(
13668            id=d.get('id'),
13669            name=d.get('name'),
13670            namespace=d.get('namespace'),
13671            server_address=d.get('server_address'),
13672            tags=d.get('tags'),
13673        )